来自 威尼斯国际官方网站 2019-10-04 13:38 的文章
当前位置: 威尼斯国际官方网站 > 威尼斯国际官方网站 > 正文

威尼斯国际官方网站:python基础语法

1.注释

Python学习网址引用

单行:# 
多行:三个'单引号'或三个"双引号"

https://www.bilibili.com/video/av10840922/?from=search&seid=7483086631377314787

'''

安装教程

print("hello world") 

https://www.python.org/downloads/windows/   官网

'''

http://www.geany.org/Download/Releases

程序好习于旧贯编辑器,用那几个比不上用pycharm社区无需付费版

"""

针对geany上有汉字报错的动静,请在历次编制程序时在前后相继第一行打上#coding=gbk

print("hello world") 

或在程序第一行打上# -*- coding: UTF-8 -*-

"""

http://www.pygame.org/news  Pygame  

2.编码

安装python正式版本后,张开CMD,输入pip install pygame就可设置pygame

python2 = assic =  不扶助中文

http://www.runoob.com/      新手教程

文件中有中文,不管是否为注释,python2实行报错。 

https://www.bilibili.com/video/av9784617/?from=search&seid=6723760175629363784#page=51                          爬虫教程(大学教师)

消除:程序首行加 #coding=utf-8 或 #*-* coding:utf-8 *-*

http://www.runoob.com/python3/python3-tutorial.html 教程,注意选python3,别选成2了

python3 = unicode = 私下认可帮助中文

https://www.jetbrains.com/pycharm/download/#section=windows       Pycharm官网,在这之中Professional是收取工资的,功用越多

3.模块:

Community 是无偿的,功用也分外有力,它能帮你搜索你发觉不了的语法错误(很体贴)

在微型Computer程序的支出进程中,随着程序代码越写更加的多,在三个文本里代码就能够进一步长,越来越不易于保险。

http://www.jb51.net/list/list_97_1.htm    学习网站

为了编写制定可尊敬的代码,大家把成千上万函数分组,分别放到分裂的文书里,那样,每种文件包涵的代码就相对比较少,非常多编制程序语言都应用这种组织代码的法子。在Python中,三个.py文件就称为二个模块(Module)。

 

使用模块有何样受益?

 

最大的裨益是大大升高了代码的可维护性。其次,编写代码不必从零初叶。当叁个模块编写达成,就足以被别的市方援引。大家在编写程序的时候,也平时援引其余模块,富含Python内置的模块和来源第三方的模块。

 

动用模块还足以幸免函数名和变量名冲突。一样名字的函数和变量完全能够分级设有不一致的模块中,因而,大家团结在编写制定模块时,不必思虑名字会与其余模块抵触。可是也要潜心,尽量不要与内置函数名字冲突。点这里查阅Python的具备内置函数。

 

您大概还悟出,假使差异的人编写的模块名一样怎么办?为了幸免模块名争辩,Python又引进了按目录来组织模块的点子,称为包(Package)。

 

举例,叁个abc.py的文件便是三个名字叫abc的模块,一个xyz.py的文本正是三个名字叫xyz的模块。

 

现行反革命,假设大家的abcxyz那多个模块名字与另外模块争辩了,于是我们得以经过包来组织模块,幸免冲突。方法是选项四个顶层包名,比方mycompany,遵照如下目录存放:

 

mycompany
├─ __init__.py
├─ abc.py
└─ xyz.py

 

引进了包之后,只要顶层的包名不与别人争辩,那具备模块都不会与别人冲突。未来,abc.py模块的名字就形成了mycompany.abc,类似的,xyz.py的模块名改成了mycompany.xyz

 

请小心,每二个包目录下边都会有三个__init__.py的文书,这一个文件是必得存在的,不然,Python就把这么些目录当成普通目录,并不是贰个包。__init__.py能够是空文件,也得以有Python代码,因为__init__.py本人正是二个模块,而它的模块名就是mycompany

 

恍如的,能够有种类目录,组成多级等级次序的包结构。比方如下的目录结构:

 

mycompany
 ├─ web
 │  ├─ __init__.py
 │  ├─ utils.py
 │  └─ www.py
 ├─ __init__.py
 ├─ abc.py
 └─ xyz.py

 

文件www.py的模块名就是mycompany.web.www,多少个文本utils.py的模块名分别是mycompany.utilsmycompany.web.utils

 

注意:和睦创设模块时要小心命名,不可能和Python自带的模块名称抵触。举个例子,系统自带了sys模块,本身的模块就不行命名为sys.py,不然将不能够导入系统自带的sys模块。

 

导入模块:

 

import package

 

from Package import specific_submodule

 

Import 模块名

 

From 模块名 import 子模块1,子模块2,......

以下内容为网络拷贝加上部分和睦收拾得来。侵删。

总结:

模块是一组Python代码的集结,能够运用别的模块,也足以被另外模块使用。

创建协和的模块时,要留意:

  • 模块名要遵守Python变量命名规范,不要选拔汉语、特殊字符;
  • 模块名不要和种类模块名争持,最佳先查看系统是还是不是已存在该模块,检查措施是在Python交互景况实行import abc,若成功则注脚系统存在此模块。

 

4.输入

name = input("请输入名字:")

5.输出

print("name is %s"%name)  

print("name:%s, age:%d"%(name,age)) 

print("name:{0}, age:{1}".format(name,age)) #(标号可不写,为默许顺序)

print("name:{name}, age:{age}".format(name = "你的名字",age = 60))

 

import math

print('常量 PI 的值近似为 {0:.3f}。'.format(math.pi)) #常量 PI 的值近似为 3.142。

 

table = {'tbl_a': 1, 'tbl_b': 2, 'tbl_c': 3}

print('tbl_b: {0[tbl_b]:d}; tbl_a: {0[tbl_a]:d}; tbl_c: {0[tbl_c]:d}'.format(table))

#tbl_b: 2; tbl_a: 1; tbl_c: 3

 

table = {'tbl_a': 1, 'tbl_b': 2, 'tbl_c': 3}

print('tbl_b: {tbl_b:d}; tbl_a: {tbl_a:d}; tbl_c: {tbl_c:d}'.format(**table))

#tbl_b: 2; tbl_a: 1; tbl_c: 3

6.类型转变

a = int("100")  # 转换为数字

a = str("100“)  # 转变为字符串

7.python2与python3

python第22中学input的剧情作为实施的剧情,python3当作字符串。如a = input(“”). python第22中学的raw_input相当于python3中的inpout。

python2 中协助 <> 是不对等的情致,python3不协助,应该用 != 表示

8.运算符

一、算述运算符:

1 + 1 = 2 (加法)

4 - 10 = -6 #(减法 - 获得负数或是多个数减去另一个数)

"a" * 5 = "aaaaa" #(乘法 - 四个数相乘或是再次回到二个被重复若干次的字符串)

2 ** 3 = 8 #(幂 - 返回2的3次幂)

5 / 2 = 2.5 #(除法)

5 // 2 = 2 #(取商 - 重回商的整数部分)

5 % 2 = 1 #(取余 - 重返除法的余数)

二、赋值运算符:

i += 1   等价于 i = i + 1
i  -= 1   等价于 i = i - 1
i  *= 2   等价于 i = i * 2
i  /= 2   等价于 i = i / 2
i  //= 2  等价于 i = i // 2
i  %= 2 等价于 i = i % 2
i  **= 2 等价于 i = i ** 2

9.逻辑运算符

not , and , or

优先级(短路原则):

and:条件1 and 标准2 ,假若基准1为假,那么那个and前后七个标准构成的表明式的图谋结果就自然为假,就不判断规范2了

  or:条件1 or 标准化2,假如前边的首先个标准为真,那么这些or前后四个条件构成的表明式的计量结果就势必为真,就不判别规范2了

10.流程

**表达式**操作运算符、常量及变量:

(1)表明式:由操作数和平运动算符组成的一句代码或讲话,表达式能够求值,可以投身" = "的侧面,用来给变量赋值。

(2)操作运算符:

<  小于

<=  小于或等于

>  大于

>=  大于或等于

==  等于,比较对象是否等于(注意区分 = ,= 是赋值,==是相比较)

!=  不等于

(3)常量:固定不改变的量,字母大写

(4)变量: 存款和储蓄新闻,未来被调用

取名法规:

    • 1.字母数字下划线组成
    • 2.无法以数字开始,不能含有特殊字符和空格
    • 3.无法以保留字命名
    • 4.不可能以汉字命名
    • 5.概念的变量名应该有含义
    • 6.驼峰式命名、下划线分割单词

    • 7.变量名分别轻重缓急写

(if...elif...else)

if 条件(如果): 

elif 条件(或如果):  

else否则:

威尼斯国际官方网站 1

注意:

  • 1、种种条件后边要选取冒号 :,表示接下去是满意条件后要举行的语句块。
  • 2、使用缩进来划分语句块,同样缩进数的口舌在一块儿构成二个语句块。
  • 3、在Python中没有switch – case语句。

例:

# 该实例演示了数字猜谜游戏
number = 7
guess = 0
print("数字猜谜游戏!")
while guess != number:
    guess = int(input("请输入你猜的数字:"))

    if guess == number:
        print("恭喜,你猜对了!")
    elif guess < number:
        print("猜的数字小了...")
    elif guess > number:
        print("猜的数字大了...")

# 试行结果:

数字猜谜游戏!
请输入你猜的数字:5
猜的数字小了...
请输入你猜的数字:6
猜的数字小了...
请输入你猜的数字:8
猜的数字大了...
请输入你猜的数字:9
猜的数字大了...
请输入你猜的数字:7
恭贺,你猜对了!

 

if 嵌套:在嵌套 if 语句中,能够把 if...elif...else 结构放在别的二个if...elif...else 结构中。

 

if 表达式1:
    语句
    if 表达式2:
        语句
    elif 表达式3:
        语句
    else:
        语句
elif 表达式4:
    语句
else:
    语句

例:

num=int(input("输入贰个数字:"))
if num%2==0:
    if num%3==0:
        print ("你输入的数字能够整除 2 和 3")
    else:
        print ("你输入的数字可以整除 2,但不能整除 3")
else:
    if num%3==0:
        print ("你输入的数字能够整除 3,但不能够整除 2")
    else:
        print ("你输入的数字不能够整除 2 和 3")

 # 实施结果:

输入一个数字:5
您输入的数字无法整除 2 和 3

输入一个数字:6
你输入的数字能够整除 2 和 3

 

(while)

while 剖断规范: #(while:当...的时候)

    语句

一、要求在乎冒号缩进。另外,在Python中没有do...while循环。

例:while 循环利用 else 语句

i = 0
while i < 5:
    print (i, " 小于 5")
    i += 1      # 变量自增
else:
    print (i, " 等于 5")

# 输出结果:

0 小于 5
1 小于 5
2 小于 5
3 小于 5
4 小于 5
5 等于 5

二、以下实例使用了 while 来总结 1 到 100 的总额:

i = 100
sum = 0
counter = 1
while counter <= i:
    sum = sum + counter
    counter += 1
print("1 到 %d 之和为: %d" % (i,sum))

# 输出结果:

1 到 100 之和为: 5050

(for)

一、for循环能够遍历任何种类的项目,如贰个列表大概三个字符串。

例:

languages = ["C", "C++", "Perl", "Python"]
for x in languages:
print (x)

# 输出结果:

C
C++
Perl
Python

二、以下 for 实例中运用了 break 语句,break 语句用于跳出当前循环体。

例:

sites = ["Baidu", "Google","frank-me","Taobao"]
for site in sites:
    if site == "frank-me":
        print("作者的网站")
        break
print("循环数据 " + site)
else:
    print("到此甘休!")
print("结束!")

 

# 输出结果:

巡回数据 Baidu
巡回数据 Google
自身的网站
结束!

注意: i++,++i 在python中不容许行使。

(range函数)

一、假让你供给遍历数字连串,能够应用内置range()函数,它会生成数列。

例:

for i in range(5):
print(i)

# 输出结果:

0
1
2
3
4

二、也得以动用range内定区间的值。

例:

for i in range(5,9) :
print(i)

# 输出结果:

5
6
7
8

三、也能够使range以钦点数字初步并点名不相同的增量(以致能够是负数,不时那也叫做'步长')。

例:

for i in range(0, 10, 3) :
print(i)

# 输出结果:

0
3
6
9

四、您能够整合range()和len()函数以遍历二个种类的目录

例:

>>> a = ['Google', 'Baidu', 'frank-me', 'Taobao', 'QQ']
>>> for i in range(len(a)):
>>> print(i, a[i])

# 输出结果:

0 Google

1 Baidu

2 frank-me

3 Taobao

4 QQ

五、能够采用range()函数来创立二个列表,用for直接历遍

>>> for i in list(range(5)):

...         print( i )

# 输出结果:

0
1
2
3
4

缩进:

break和continue语句及循环中的else子句

一、break 语句能够跳出 for 和 while 的循环体。倘诺您从 for 或 while 循环中停止,任何对应的循环 else 块将不奉行。

例:

for letter in 'frank-me': # 第叁个实例
    if letter == '-':           # 当符号为“-”时,跳出
        break
    print ('当前字符为 :', letter)

var = 10 # 第三个实例
while var > 0:
    print ('当期变量值为 :', var)
    var = var -1
    if var == 5:               # 到数字5(包涵5)时不往下进行
        break

print ("See you!")

# 输出结果:

日前字符为 : f
时下字符为 : r
现阶段字符为 : a
眼下字符为 : n
眼前字符为 : k
当期变量值为 : 10
当期变量值为 : 9
当期变量值为 : 8
当期变量值为 : 7
当期变量值为 : 6
See you!

二、continue语句被用来报告Python跳过当前循环块中的剩余语句,然后继续举办下一轮循环。

例:

for letter in 'frank-me': # 第三个实例
    if letter == '-': # 字符为 "-" 时跳过输出,继续往下实施
        continue
    print ('当前字符 :', letter)

var = 10 # 第二个实例
while var > 0:
    var = var -1
    if var == 5: # 变量为 5 时跳过输出,继续往下举行
        continue
    print ('当前变量值 :', var)
print ("See you!")

# 输出结果:

近些日子字符 : f
日前字符 : r
目前字符 : a
脚下字符 : n
此时此刻字符 : k
现阶段字符 : m
日前字符 : e
日前变量值 : 9
当下变量值 : 8
时下变量值 : 7
现阶段变量值 : 6
眼下变量值 : 4
眼前变量值 : 3
脚下变量值 : 2
此时此刻变量值 : 1
如今变量值 : 0
See you!

三、循环语句能够有 else 子句,它在穷尽列表(以for循环)或标准成为 false (以while循环)导致循环终止时被实施,但循环被break终止时不进行。

例:

for i in range(2, 10):
    for x in range(2, i):
        if i % x == 0:
            print(i, '=', x, '*', i//x)
            break
    else:
    # 循环中一向不找到成分
    print(i, '是质数')

# 输出结果:

2 是质数
3 是质数
4 = 2 * 2
5 是质数
6 = 2 * 3
7 是质数
8 = 2 * 4
9 = 3 * 3

 

for-else

 

for中并未有break,则else一定会实践

for temp in strs: 

   print(temp)   

else: 

   print("")

 

const 修退换量为不可变。

 

(pass语句)

pass是空语句,是为着保持程序结构的完整性。

pass 不做其余职业,日常用做占位语句。

while True:
    pass # 等待键盘中断 (Ctrl+C)

小小的的类:

class EmptyClass:
    pass

例:

for letter in 'frank-me':
    if letter == '-':
        pass
    print ('- 执行 pass')
print ('当前字符 :', letter)

print ("See you!")

# 输出结果:

脚下字符 : f
此时此刻字符 : r
这几天字符 : a
日前字符 : n
眼前字符 : k

  • 执行 pass
    脚下字符 : -
    此时此刻字符 : m
    现阶段字符 : e
    See you!

11.字符串(不可变)

一、创建
       ‘ str ’,“ str ”单引号或双引号包裹起来的内容
       顺序,序列
           -- 偏移量,索引,直标
       长度
           --len()重临三个行列的长度
       ** 单个字符,即长度为1的字符串

二、索引
       test_str[0]
       ** 特别的:最终一成分的目录“-1”,“-2”代表尾数第二,就那样类推
       切片
           -- test_str[strat:end]
           -- start:开始索引(满含那个成分)
           -- end:结束索引(不含有那几个因素)
           -- start < end
       不可变
           -- 不可能修改

切片例:

str = "dasfaf"

str[2:4] #(取得2到3的), 

str[2:]  #(到最后), 

str[2:-1:2] #(步长2,隔二个取一个)

逆序:

str = "abcdefABCDEF" 

str[0:]  # out:"abcdefABCDEF" (顺序)

str[-1:]  # out:"F" (尾数第三个)

str[-1:0]  # out:"" 

str[-1:0:-1]  # out:"FEDChina Basketball Associationfedcb" (逆序,不含第二个)

str[-1::-1], str[::-1]  # out:"FEDCBAfedcba"(逆序

 

三、字符串连接:

a = b + c  #或者

a = "===%s==="%(b+c)  #或者

a = "==={}===".format(b+c)

四、常见操作

find: str.find("abc")  # 从左向右有重临第多个相称字符串的序幕下标,未有再次来到-1。rfind():从右向左。 

str.index("abc")  #找到重临起头下标,未有抛出特别。 存在rindex(). 

str.count("abc")  #合营的个数。

 

str.replace("abc", "def")  #同java,把左边手的替换来右侧的 。

str.replace("abc", "def",1)  #其多个参数是从左到右替换个数。 

 

str.split(" ")  #同java ,通过点名分隔符(包罗空格、换行(n)、制表符(t)等)对字符串进行切开,若是参数 num 有钦定

          值,则仅相隔 num 个子字符串。

str.capitalize()  #字符串的率先个假名大写。 

str.title()  #字符串的每一种单词的首字母大写。 

str.startswith("abc"), str.endswith("abc")  #同java,用于检查字符串是不是是以钦点子字符串开端,假设是则赶回 True,

                            不然赶回 False。假如参数 beg 和 end 钦命值,则在内定范围内检查。

str.lower() str.uper()  #持有的字母小写和题诗。 

str.center(50)  #从中呈现,行总市长50 "     abc     "

str.ljust(50), str.rjust(50)  #左(右)对齐

 

str.lstrip()  #删去左边空格

str.rstrip()  #出手空格

str.strip()  #去除两端空格.

12.列表 (类似数组,可变,针对作者的改换)

运算符

表达式

结果

描述

len([1, 2, 3])

3

计量元素个数

[1, 2, 3] + [4, 5, 6]

[1, 2, 3, 4, 5, 6]

连接

[‘Hi!’] * 4

[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]

复制

3 in [1, 2, 3]

True

要素是或不是留存

for x in [1, 2, 3]: print(x, end=” “)

1 2 3

迭代

创建
    序列
    list1 = [1,2,3,4,5,6]

例:

["zhangsan","lisi"]

#定义

names = ["zhangsan", "lisi", 3.14]  #列表中的数据能够是分歧的数据类型。  可以下标,和切块。

增加和删除改查

   
    -- 1.list.append(item)向后面部分增添
    -- 2.list.insert(index,item) 向钦点的地点插入

例:#增

names.append("abc") #-->插入到最后; 

names.insert(0, "bcc") #-->插入内定地点。 

names = names1 + names2 #四个列表用连接符

names1.extend(names2) #扩充

#小心:append增多的因素;extend连接的列表

   
    -- list.pop(index)  #-->index 暗中认可-1 (最终一个)

例:#删

names.pop() #-->删除最终四个; 

names.remove("lisi") #-->依据剧情剔除; 

del names[0] #-->下标删除

   

    -- 直接复制

例:#改

names[0] = "abc" 

   
    索引
    操作同字符串

例:#查

name[1:] # "lisi"

in, not in #是不是留存 (if "zhangsan" in names:) 

#能够for... in 循环遍历

len(names) #要素个数 

 

13.字典(可变)

a = {"name":"yy", "age": 12}

 

a["name"] = "yy" #直接写key-value 

del a["name"]

a["name"] = "zz" #同一key的值覆盖。

a["name"], a.get("name")

例:

>>> params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}
>>> params
{'server': 'mpilgrim', 'database': 'master', 'uid': 'sa', 'pwd': 'secret'}

>>> ["%s=%s" % (k, v) for k, v in params.items()]
['server=mpilgrim', 'database=master', 'uid=sa', 'pwd=secret']

>>> ";".join(["%s=%s" % (k, v) for k, v in params.items()])
'server=mpilgrim;database=master;uid=sa;pwd=secret'

 

 
字典常见操作

len(params) #键值对的个数

 

params.keys() 或 dict.keys(params) #返回key的列表

if "uid" in params.keys(): #认清是或不是留存某些key

    print("yes")

params.values() #返回value的列表

 

14.元组(类似列表,不可变)

列表能够增加和删除改,元组不可能改

tup1 = (); #空元组

例:

>>> tup1 = (50)

>>> type(tup1)     # 不加逗号,类型为整型

# 推行结果:

<class 'int'>

 

>>> tup1 = (50,)

>>> type(tup1)     # 加上逗号,类型为元组

# 实践结果:

<class 'tuple'>

 

访问:

例:

tup1 = ('Google', 'Baidu', 1997, 2000)

tup2 = (1, 2, 3, 4, 5, 6, 7 )

 

print ("tup1[0]: ",tup1[0])

# 试行结果:

tup1[0]:  Google

 

print ("tup2[1:5]: ", tup2[1:5])

# 试行结果:

tup2[1:5]:  (2, 3, 4, 5)

 

修改:

例:

tup1 = (12, 34.56);

tup2 = ('abc', 'xyz')

 

# 以下修改元组成分操作是私行的。

# tup1[0] = 100

 

# 创立二个新的元组

tup3 = tup1 + tup2;

print (tup3) #(12, 34.56, 'abc', 'xyz')

 

删除

tup = ('Google', 'Baidu', 1997, 2000)

 

print (tup)

del tup;

 

就如拆包

a = (11,12)

b = a

b #out (11,12)

c,d = a #好像拆包

c #out 11

d #out 12

 

例:

info = {"name":"ysw", "age":24}

for temp in info:

    print(temp)

# 实施结果:

name

 age

 

for temp in info.items():

    print("key=%s,value=%s"%(temp[0],temp[1]))

#or(或者)

for a,b in info.items():

    print("key=%s,value=%s"%(a,b))

# 施行结果

key=name,value=ysw
key=age,value=24

 

遍历本事

一、在字典中遍历时,关键字和对应的值能够使用 items() 方法同一时候解读出来

knights = {'gallahad': 'the pure', 'robin': 'the brave'}

for k, v in knights.items():

          print(k, v)

 

# 试行结果:

gallahad the pure

robin the brave

 

二、在系列中遍历时,索引地点和对应值能够动用 enumerate() 函数同一时间获取

>>> for i, v in enumerate(['tic', 'tac', 'toe']):

...     print(i, v)

 

# 推行结果:

0 tic

1 tac

2 toe

 

三、同一时间遍历三个或越来越多的行列,能够运用 zip() 组合

>>> questions = ['name', 'quest', 'favorite color']

>>> answers = ['lancelot', 'the holy grail', 'blue']

>>> for q, a in zip(questions, answers):

...     print('What is your {0}?  It is {1}.'.format(q, a))

...

# 试行结果:

What is your name?  It is lancelot.

What is your quest?  It is the holy grail.

What is your favorite color?  It is blue.

 

四、要反向遍历一个类别,首先钦定那个行列,然后调用 reversed() 函数

>>> for i in reversed(range(1, 10, 2)):

...     print(i)

...

# 推行结果:

9

7

5

3

1

 

五、要按梯次遍历一个行列,使用 sorted() 函数再次来到贰个已排序的队列,并不退换原值

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']

>>> for f in sorted(set(basket)):

...     print(f)

...

# 推行结果:

apple

banana

orange

pear

 

15.函数

def abc():

    print("")

 

abc()

#静心: 函数的定义供给在函数的调用在此以前,不然报错。

可改变与不足更换对象: 
在python中,strings,tuples和numbers是不足退换对象,list.dict等则是可退换对象。 

  • 不得变类型:变量赋值 a=5后在赋值a=10,生成了新的指标,原对象抛弃。 
  • 可变类型:变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第一个成分值更动,自己la未有动,只是当中间的一部分值被改造了。

python 函数的参数字传送递: 

  • 不行变类型:类似 c++ 的值传递,如 整数、字符串、元组。如fun(a),传递的只是a的值,未有影响a对象自笔者。比方在 fun(a)内部修改 a 的值,只是修改另一个复制的靶子,不会影响 a 本身 
  • 可变类型:类似 c++ 的援用传递,如 列表,字典。如 fun(la),则是将 la 真正的传过去,修改后fun外界的la也会受影响

 

一、默许函数参数 

def printinfo( name, age = 35 ):

   "打字与印刷任何传入的字符串"

   print ("名字: ", name);

   print ("年龄: ", age);

   return;

 

printinfo( age=50, name="baidu" );

print ("------------------------")

printinfo( name="baidu" );

 

 # 实践结果:

名字:  baidu

年龄:  50


名字:  baidu

年龄:  35

 

二、可变参数

例:

def printinfo( *vartuple ):

   "打字与印刷任何传入的参数"

   print ("输出: ")

   for var in vartuple:

      print (var)

   return;

 

printinfo(10,32,22)

 

#佚名函数(lambda创设无名氏函数)

 

sum = lambda arg1, arg2: arg1 + arg2;

 

print ("相加后的值为 : ", sum( 10, 20 ))

print ("相加后的值为 : ", sum( 20, 20 ))

 

# 实践结果:

输出:
10
32
22
相加后的值为 : 30
相加后的值为 : 40

 

三、global关键字修改外界成效域变量

例:

num = 1

def fun1():

    global num  # 供给使用 global 关键字注解

    print(num)

    num = 123

    print(num)

fun1()

#  试行结果:

1

123

 

四、nonlocal 修改嵌套功效域变量

例:

def outer():

    num = 10

    def inner():

        nonlocal num   # nonlocal关键字表明

        num = 100

        print(num)

    inner()

    print(num)

outer()

 

# 实行结果:

100

100

 

16.迭代器和生成器

一、字符串,列表和元组对象都可用来创造迭代器。

例:

list = [1,2,3,4]

it = iter(list)

print(next(it)) 

print(next(it)) 

 

#进行结果

1

2

 

for x in it:  #遍历

    print(x, end = "")

#实行结果:

1 2 3 4

 

 例:

import sys

list = [1,2,3,4]

it = iter(list)

while True:

    try:

        print(next(it))

    except StopIteration:

        sys.exit()

# 实施结果:

1

2

3

4

 

二、生成器(TODO) 

yield 的函数,生成器是回到迭代器的函数,只可以用于迭代操作。

例:

import sys

 

def fibonacci(n): # 生成器函数 - 斐波这契

    a, b, counter = 0, 1, 0

    while True:

        if (counter > n):

            return

        yield a               # 相当于generator的print(a)

        a, b = b, a + b   # 注意,赋值语句相当于:t = (b,a+b), t 是多个tuple,a = t[0] , b = t[1]

        counter += 1

f = fibonacci(10) # f 是三个迭代器,由生成器再次回到生成

 

while True:

    try:

        print (next(f), end=" ")

    except StopIteration:

        sys.exit()

 

#推行结果:

0 1 1 2 3 5 8 13 21 34 55

 

17.模块

 Python 提供了一个主意,把一些定义贮存在文书中,为部分本子或许交互式的解释器实例使用,这么些文件被称呼模块。 

  • import语句,想行使 Python 源文件,只需在另一个源文件里进行 import 语句。

例:

#!/usr/bin/python3

# Filename: support.py

 

def print_func( par ):

    print ("Hello : ", par)

    return

 

#!/usr/bin/python3

# Filename: test.py

 

 

import support #导入模块,即文件名

 

# 今后能够调用模块里包罗的函数了

support.print_func()

 

from…import语句,从模块中程导弹入多个内定的片段到近年来命名空间中。

#导入模块 fibo 的 fib 函数

from fibo import fib, fib2

>>> fib(500)

  • From…import* 语句,把三个模块的富有剧情全都导入到当前的命名空间。
  • 模块除了艺术定义,还是能富含可进行的代码。那个代码日常用来开端化这么些模块。那几个代码独有在首先次被导入时才会被实施。
  • name属性,贰个模块被另二个顺序第三次引进时,其主程序将运营。倘使大家想在模块被引进时,模块中的某一程序块不实施,能够用name属性。

例:

#!/usr/bin/python3

# Filename: using_name.py

 

if __name__ == '__main__':

   print('程序本人在运作')

else:

   print('作者来自另一模块')

 

#实行结果:

前后相继本身在运作

 

  • Python 会依据 sys.path 中的目录来查找那几个包中包罗的子目录。
  • 目录唯有饱含一个叫做 init.py 的公文才会被认作是三个包,主就算为着制止有些滥俗的名字(比如叫做 string)比相当大心的震慑寻觅路线中的有效模块。
  • 推荐:from Package import specific_submodule

18.文件

open()方法重返文件,第一个参数为文件展开药格局。默许只读r / 写w,a追加…

f = open("/tmp/test.txt","w")

 

f.write("人生苦短,作者用python!")

 

f.close()

  • f.read(size) 读取文件内容,size为空或负数则整个回到。
  • f.readline() 会从文件中读取单独的一行。换行符为 ‘n’。f.readline() 要是回到二个空字符串, 表明已经已经读取到最后一行。
  • f.readlines() 读取文件全数行,并以列表再次回到。
  • f.write(string) 将 string 写入到文件中, 然后回来写入的字符数。假设要写入一些不是字符串的东西, 那么将索要先进行调换。

19.类

类方法

例:

class MyClass:

    i = 12345

    #类措施必需有三个特出的第三个参数,惯例是self,不固定;代表的的类的实例而非类

    def f(self):

        return "hello world"

 

x = MyClass()

print("MyClass 类的性质 i 为:", x.i)

print("MyClass 类的主意 f 输出为:", x.f())

 

#施行结果:

MyClass 类的特性 i 为: 12345
MyClass 类的方法 f 输出为: hello world

 

构造方法

例:

class Complex:

    #构造方法

    def __init__(self, realpart, imagpart):

        self.r = realpart

        self.i = imagpart

x = Complex(3.0, -4.5)

print(x.r, x.i)  

 

# 施行结果:

3.0 -4.5

 

例: 

类定义

class people:

    #概念基特性情

    name = ''

    age = 0

    #概念私有属性,私有属性在类外界不能直接开展拜望

    __weight = 0

#概念构造方法

    def __init__(self,n,a,w):

        self.name = n

        self.age = a

        self.__weight = w

    def speak(self):

        print("%s 说: 我 %d 岁。" %(self.name,self.age))

 

# 实例化类

p = people('baidu',10,30)

p.speak()

 

 # 实施结果:

baidu 说: 我 10 岁。

 

继承

例:

类定义

class people:

    #概念基本属性

    name = ''

    age = 0

    #概念私有属性,私有属性在类外界无法直接开展拜望

    __weight = 0

    #概念构造方法

    def __init__(self,n,a,w):

        self.name = n

        self.age = a

        self.__weight = w

    def speak(self):

        print("%s 说: 我 %d 岁。" %(self.name,self.age))

 

#单承继示例

class student(people):

    grade = ''

    def __init__(self,n,a,w,g):

        #调用父类的构函

        people.__init__(self,n,a,w)

        self.grade = g

    #覆写父类的秘诀

    def speak(self):

        print("%s 说: 我 %d 岁了,我在读 %d 年级"%(self.name,self.age,self.grade))

 

#另二个类,多重继承之前的预备

class speaker():

    topic = ''

    name = ''

    def __init__(self,n,t):

        self.name = n

        self.topic = t

    def speak(self):

        print("笔者叫 %s,作者是二个解说家,笔者发言的宗旨是 %s"%(self.name,self.topic))

 

#多种承继

class sample(speaker,student):

    a =''

    def __init__(self,n,a,w,g,t):

        student.__init__(self,n,a,w,g)

        speaker.__init__(self,n,t)

 

test = sample("frank",25,80,4,"Python")

test.speak()   #办法名同,暗许调用的是在括号中排前地父类的议程

 

# 推行结果:

自己叫 frank,笔者是贰个演讲家,笔者发言的核心是 Python

 

20.正则表达式

      re.match与re.search的区别 
      re.match只相配字符串的初始,假诺字符串开始不切合正则表明式,则相称退步,函数重临None;而re.search相配整个字符串,直到找到三个卓越。

例:

import re

 

line = "Cats are smarter than dogs";

matchObj = re.match( r'dogs', line, re.M|re.I)

if matchObj:

   print ("match --> matchObj.group() : ", matchObj.group())

else:

   print ("No match!!")

 #实施结果

   No match!!

 

例:

import re

 

line = "Cats are smarter than dogs";

matchObj = re.search( r'dogs', line, re.M|re.I)

if matchObj:

   print ("search --> matchObj.group() : ", matchObj.group())

else:

   print ("No match!!")

 #实施结果

   search --> matchObj.group() :  dogs

 

搜索和替换

例:

import re

phone = "2018-666-666 # 那是二个电话号码" 

num = re.sub(r'#.*$', "", phone)   # 删除“#”前面包车型大巴注释内容

print ("电话号码 : ", num)

 

#施行结果

电话号码 :  2018-666-666 

 

例:

import re

phone = "2018-666-666 # 这是多个电话号码" 

num = re.sub(r'D', "", phone) # 移除非数字的内容

print ("电话号码 : ", num)

 

#实践结果

电话号码 :  2018666666

 

末段用一张图来总结:

威尼斯国际官方网站 2

Python的为主!Python PEP 8建议每级缩进都使用多个空格,那既可压实可读性,又留下了十足的家家户户缩进空间。在字管理文书档案中,大家日常使用制表符并非空格来缩进。对于文字管理文书档案来说,那样做的职能很好,但混合使用制表符和空格会让Python解释器感觉迷惑。每款文本编辑器都提供了一种设置,可将输入的制表符转变为钦赐数量的空格。你在编辑代码时应有使用制表符键,但确定要对编辑器举行设置,使其在文书档案中插入空格并不是制表符。在前后相继中掺杂使用制表符和空格大概变成极难解决的主题素材。若是你混合使用了制表符和空格,可将文件中全数的制表符转变为空格,大多数编辑器都提供了那般的机能。(能够不看,缩进就是Tab键)

缩进错误会冒出如下报错:

IndentationError: unexpected indent 错误是 python 编写翻译器是在告知你"Hi,老兄,你的文本里格式不对了,恐怕是tab和空格没对齐的标题",全部 python 对格式供给特别严格。

如果是 IndentationError: unindent does not match any outer indentation level错误声明,你使用的缩进方式分裂样,有的是 tab 键缩进,有的是空格缩进,改为同一就可以。

之所以,在 Python 的代码块中必得使用一样数量的行首缩进空格数。

提出你在每一种缩进档案的次序使用 单个制表符 或 五个空格 或 三个空格 , 切记不可能混用。

 

空行:

函数之间或‘类’的措施之间用空行分隔,表示一段新的代码的初阶。类和函数入口之间也用一行空行分隔,以崛起函数入口的启幕。

空行与代码缩进不一致,空行并非Python语法的一有的。书写时不插入空行,Python解释器运转也不会出错。不过空行的功用在于分隔两段分化功能或含义的代码,便于日后代码的保养或重构。

铭记:空行也是程序代码的一片段。

 

python保留字:

保留字即注重字,大家不可能把它们作为其余标识符或变量名称。Python 的标准库提供了贰个 keyword 模块,能够出口当前版本的有着首要字:

>>> import keyword

>>> keyword.kwlist

['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

 

多行语句:

Python 日常是单排写完一条语句,但就算语句不长,大家能够运用反斜杠()来促成多行语句,比如:total = 'item_one' +

               'item_two' +

                'item_three'

 

在 [], {}, 或 () 中的多行语句,无需接纳反斜杠(),例如:

total =['item_one',  ‘item_two’, ‘item_three’

               'item_four',  'item_five' ]

本文由威尼斯国际官方网站发布于威尼斯国际官方网站,转载请注明出处:威尼斯国际官方网站:python基础语法

关键词: