python基本语法教程,python语言参考手册

1、数学计算：

n的m次方：n**m

n除以m的整数值：n // m

n除以m的浮点值：n / m

Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，

复数的实部a和虚部b都是浮点型

tuple的元素不可改变，但它可以包含可变的对象，可变对象中的元素可以改变。

string、list和tuple都属于sequence(序列)

集合(set)的运算：- | & ^

2 进制是 0b

8 进制是 0o

16 进制是 0x

创建一个空集合用 set()

创建一个空字典用 { }python编程代码看不懂怎么办。

2、转义字符输出，添加 r 使用原始字符

反斜杠可以用来转义，使用r可以让反斜杠不发生转义。。 如 r"this is a line with \n" 则\n会显示，并不是换行。

print('C:\name\111')

#输出 C:

ame\111

print(r'C:\name\111')

#输出 C:\name\111

3、多行输出,去除第一行换行加 \

print('''

nihao

zaima

''')

#输出

[space]

nihao

zaima

print('''\

nihao

zaima

''')

#输出

nihao

zaima

3、使用 + 进行字符串的连接，使用 * 进行字符串的重复

Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。

3*'aaa'+'bbb'

#输出

aaaaaaaaabbb

4、最后式子的值作为下面的输入 _

'aaaa'

a=_

print(a)

#输出

aaaa

3*5

3+_

#输出

18

5、多个赋值,右侧的表达式在赋值发生之前都是计算的

a,b=1,2

a,b=a,a+b

a,b

#输出

(2,3)

6,print()输出

print('aaaa',end=',')

print('bbbb')

#输出

aaaabbbb

7、在循环内修改正在迭代的序列(例如，复制所选的项目)，建议首先创建原序列的拷贝。

对序列进行迭代不会隐式地进行复制。

切片符号使这特别方便：

for w in words[:]: # Loop over a slice copy of the entire list.

if len(w) > 6:

words.insert(0, w)

>>> words

['defenestrate', 'cat', 'window', 'defenestrate']

for w in words:

if len(w) > 6:

words.insert(0, w)

#死循环

8、for循环的else子句在未出现break时运行

for x in range(7):

if x>5:

print(x)

break

else:

print('else')

#输出

6

for x in range(7):

if x>5:

print(x)

else:

print('else')

#输出

6

else

9、默认值在函数定义的时刻，在定义的作用域中计算，当默认值是一个可变对象(如列表，字典或大多数类的实例)时，这会产生不同。

i=5

def f(arg=i):

print(arg)

i=6

f()

#输出

5

def f(a,L=[]):

L.append(a)

return L

f(1) #输出[1]

f(2) #输出[1,2]

f(3) #输出[1,2,3]

如果你不想在后续调用之间共享默认值，你可以写这样的函数

def f(a,L=None):

if L is None:

L=[]

L.append(a)

return L

10、如果存在一个**name形式的形式参数，它将接收一个字典(参见映射类型——字典)，这个字典包含除形式参数之外的所有关键字参数。

它可以与*name形式的形式参数组合，这种形式接收一个元组，这个元组包含除形式参数之外的所有位置参数。(*name必须出现在**name之前)

def test(**kr):

return kr

def test2(*z):

return z

def test3(*kr,**z):

return kr,z

def test4(a,b=1,e=3,*c,**d):

return a,b,e,c,d

print(test(a=4,b=2,c=5))

print(test2(1,2,3,4))

print(test3('a','b','c',a=1,b=3))

print(test4(1,1,2,2,3,4,c=5))

#输出

{'a': 4, 'b': 2, 'c': 5}

(1, 2, 3, 4)

(('a', 'b', 'c'), {'a': 1, 'b': 3})

(1, 1, 2, (2, 3, 4), {'c': 5})

11、函数：string.join()

join()：连接字符串数组。将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串

def testJoin(*arg,seq='/'):

return seq.join(arg)

print(testJoin('D:','com','geng'))

print(testJoin('D:','com','geng',seq='\\'))

#输出

D:/com/geng

D:\com\geng

12、Lambda函数可用于需要函数对象的任何地方。它们在语法上限于单个表达式。语义上，它们只是用于正常函数定义的语法

def func(n):

return lambda x,y:x+y+n

f=func(1)

print(f)

print(f(1,23))

print(f(2,3))

pair=[(1,2),(3,7),(4,3)]

pair.sort(key=lambda x:x[1])

print(pair)

13、函数注解

注解以字典形式存储在函数的__annotations__属性中，对函数其它任何部分没有任何影响。

参数注解的定义是参数名后面跟着一个冒号，然后紧跟着一个用于计算注解的表达式。

def functest(t:str,eg:int=1)->str:

print(functest.__annotations__)

print(t+'aaa',eg)

functest('11111', 111)

#输出

{'t': , 'eg': , 'return': }

11111aaa 111

def my_function():

"""Do nothing, but document it.

No, really, it doesn't do anything.

"""

pass

print(my_function.__doc__)

#输出

Do nothing, but document it.

No, really, it doesn't do anything.

14、string.strip(str),

声明：string为字符串，str为要删除的字符序列

s.strip(rm)      删除s字符串中开头、结尾处，位于rm删除序列的字符

s.lstrip(rm)     删除s字符串中开头处，位于rm删除序列的字符

s.rstrip(rm)     删除s字符串中结尾处，位于rm删除序列的字符

string.strip(' ')

'111 2222 333 444'

string.lstrip(' ')

'111 2222 333 444 '

string.rstrip(' ')

' 111 2222 333 444'

!!!!!!!当rm为空时，默认删除空白符(包括'\n', '\r',  '\t',  ' ')

string=''' \n nihao \t'''

string.strip()

'nihao'

15、zip()函数接受任意多个(包括0个和1个)序列作为参数，返回一个tuple列表

a=[[1,2,3,4],[5,6,7],[8,9,10,11,12]]

list(zip(*a))

>>>[(1, 5, 8), (2, 6, 9), (3, 7, 10)]

list(zip(a))

>>>[([1, 2, 3, 4],), ([5, 6, 7],), ([8, 9, 10, 11, 12],)]

aa=[1,2,3]

bb=[1,2]

cc=[1,2,3,4]

zip(aa,bb,cc)

[(1, 1, 1), (2, 2, 2)]

16、当循环遍历字典时，键和对应的值可以使用items()方法同时提取出来。

k={'111':1,'222':2,'33333':3}

for k,v in k.items():

print(k,':',v)

111 : 1

222 : 2

33333 : 3

17、两个或更多的序列，使用zip()函数可以成对读取元素。

q=['name','age','sex']

a=['geng',23,'man']

for x,y in zip(q,a):

print('{0}:{1}'.format(x,y))

18、is和is not比较两个对象是否为相同的对象；这只对列表这样的可变对象比较重要

x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False，id() 函数用于获取对象内存地址。

19、str()与repr(),str()用于显示人类所看到的，repr()用于编译所看到的

s='\n'

str(s) #输出 \n

repr(s) #输出 \\n #编译时对 \ 进行了转义

20、str.center()、str.ljust(int)和str.rjust(int),str占用int个字节，并且左右对齐

如果输入的字符串太长，字符串不会被截断，会完整输出。

a='10'

a.center(5) #' 10 '

a.ljust(5) #'10 '

a.rjust(5) #' 10'

如果你真的想要截断，可以加上一个切片操作，例如x.ljust(n)[:n],不过将失去对齐方式

21、str.zfill()，它向数值字符串左侧填充零。它理解加号和减号，超出是也不会截断

'-3.14'.zfill(7)

#'-003.14'

22、str.format()

'!a'(运用ascii())、'!s'(运用str())和'!r'(运用repr())可以用来在格式化之前转换相应的值。

':'后面紧跟一个整数可以限定该字段的最小宽度。

print('---{1!r:10}---{2!a:10}---{0!s:10}---'.format("111\n","222\n","3333\n"))

#输出

---'222\n' ---'3333\n' ---111

---

可以传入一个字典，然后使用'[]'访问

dict={"str":"string",10:10,"PI":3.1415926}

print('str{0[str]:10s},int{0[10]:5d},{0[PI]:.3f}'.format(dict))

#输出

strstring ,int 10,3.142

23、其他类型的对象,在写入之前则需要转换成 字符串 (在文本模式下) 或 字节对象 (以

二进制模式)

value = ('the answer', 42)

s = str(value) # convert the tuple to string

f.write(s)

#文件中显示

('the answer', 42)

24、f.seek(offset, from_what)更改该文件对象的位置，

from_what可以省略，默认为0，使用文件的开头作为参考点。

当from_what的值为0，1，2 时，分别使用文件开头、当前文件位置和文件结尾作为参考点

位置由参考点加上offset 计算得来。

f=open('test.txt','rb+')

print(f.write(b'011234567asdcvfg'))

f.seek(5) #默认0开始读取

print(f.read(1))

print(f.tell()) #当前位置

f.seek(5,1) #当前位置开始读取

print(f.read(1))

f.seek(-1,2) #文件末尾开始读取

print(f.read(1))

#输出

16

b'4'

6

b'd'

b'g'

25、file.tell()返回一个整数，代表文件对象在文件中的当前的位置，

在二进制模式中该数值表示自文件开头到指针处的字节数，在文本模式中则是不准确的。

例题看上面

在文本文件中(没有以b模式打开的文件)，只允许从文件的开始查找(有个例外是查找到文件的末尾seek(0, 2))，

而且offset只有是从f.tell()返回的值或者是0才是合法的。任何其他偏移值会产生未定义的行为。

26、使用json存储结构化数据

json.dumps([1, 'simple', 'list'])

>>>'[1, "simple", "list"]'

dumps()函数的另外一个变体dump()，直接将对象序列化到一个文本文件。

如果f是为写入而打开的一个文件对象

json.dump(object, file)

为了重新解码对象，如果f是为读取而打开的文本文件对象 ：

object = json.load(f)

27、type与isinstance

type()不会认为子类是一种父类类型。

isinstance()会认为子类是一种父类类型

class A:

pass

class B(A):

pass

isinstance(A(), A) # returns True

type(A()) == A # returns True

isinstance(B(), A) # returns True

type(B()) == A # returns False

27、构造函数 dict() 可以直接从键值对序列中构建字典

dictE = dict ([("ee",11), ("aaa", "bbbb"), (123, 123), (True, True)]);

print (dictE);

dictF = {x: x*2 for x in (2, 4, 6)};

print (dictF);

dictG = dict (name = 1, goole = "name", bool = True);

print(dictG);

28、isdigit、isnumeric、isdecimal的差别

isdigit()

True: Unicode数字，byte数字(单字节)，全角数字(双字节)，罗马数字

False: 汉字数字

Error: 无

isdecimal()

True: Unicode数字，，全角数字(双字节)(十进制)

False: 罗马数字，汉字数字

Error: byte数字(单字节)

isnumeric()

True: Unicode数字，全角数字(双字节)，罗马数字，汉字数字

False: 无

Error: byte数字(单字节)

29、 splitlines()

按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，

如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

print ('ab c\n\nde fg\rkl\r\n'.splitlines());

print ('ab c\n\nde fg\rkl\r\n'.splitlines(True));

>>>

['ab c', '', 'de fg', 'kl']

['ab c\n', '\n', 'de fg\r', 'kl\r\n']

30、list.copy()与 = 赋值

使用 = 直接赋值，是引用赋值，更改一个，另一个同样会变；

copy() 则顾名思义，复制一个副本，原值和新复制的变量互不影响；

31、

循环语句可以有 else 子句，

它在穷尽列表(以for循环)或条件变为 false (以while循环)

导致循环终止时被执行,但循环被break终止时不执行。

sites = ['1', '2', '3', '4'];

for site in sites:

if site == '3':

print ("找到了");

break;

print ("循环数据 " + site);

else:

print ("没有循环数据!");

print ("完成循环!");

>>>

循环数据 1

循环数据 2

找到了

完成循环

32、Python的作用域一共有4种，分别是：

L (Local) 局部作用域

E (Enclosing) 闭包函数外的函数中

G (Global) 全局作用域

B (Built-in) 内建作用域

以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找(例如闭包)，再找不到就会去全局找，再者去内建中找。

x = int(2.9) # 内建作用域

g_count = 0 # 全局作用域

def outer():

o_count = 1 # 闭包函数外的函数中

def inner():

i_count = 2 # 局部作用域

Python中只有模块(module)，类(class)以及函数(def、lambda)才会引入新的作用域，其它的代码块(如if/elif/else/、try/except、for/while等)是不会引入新的作用域的，也就是说这这些语句内定义的变量，外部也可以访问

33、默认参数必须放在最后面，否则会报

34、global 和 nonlocal关键字

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。

global关键字用来在函数或其他局部作用域中使用全局变量。

nonlocal关键字用来在函数或其他作用域中使用外层(非全局)变量

35、def(**kwargs) 把N个关键字参数转化为字典:

>>> def func(country,province,**kwargs):

... print(country,province,kwargs)

...

>>> func("China","Sichuan",city = "Chengdu", section = "JingJiang")

China Sichuan {'city': 'Chengdu', 'section': 'JingJiang'}

>>>

36、同时遍历两个或更多的序列，可以使用 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))

...#print('what is your %s? it is %s' %(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.

37、在:file:sounds/effects/__init__.py中包含如下代码:

__all__ = ["echo", "surround", "reverse"]

这表示当你使用from sound.effects import *这种用法时，你只会导入包里面这三个子模块。

38、使用del语句删除一些对象引用。

del var1[,var2[,var3[....,varN]]]]

39、注意：

Python可以同时为多个变量赋值，如a, b = 1, 2。

一个变量可以通过赋值指向不同类型的对象。

数值的除法(/)总是返回一个浮点数，要获取整数使用//操作符。

在混合计算时，Python会把整型转换成为浮点数。

40、集合(set)是一个无序不重复元素的序列。

基本功能是进行成员关系测试和删除重复元素。

可以使用大括号 { } 或者 set() 函数创建集合。

41、

字典是一种映射类型，它的元素是键值对。

字典的关键字必须为不可变类型，且不能重复。

创建空字典使用 { }。

42、

x and y布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。

x or y布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。

not x布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

43、

repr(x)

将对象 x 转换为表达式字符串

eval(str)

用来计算在字符串中的有效Python表达式,并返回一个对象