为什么想学python呢？是为了刷leetcode的，因为每次刷leetcode时候我用js别人用python，效率真的不是一个档次的，直到半年前学了python基础语法后发现真香。但是最近几个月没刷导致python忘了大部分，所以需要复习下，但是之前没整理文档，重新学习起来有点烦。所以现在整理下，防止下次忘了，没地方复习。。
巩固语法最好的地方就是用python刷leetcode，哪里不会学哪里。
基础语法
# 第一个注释
# 第二个注释
'''
第三注释
第四注释
'''
"""
第五注释
第六注释
"""
print ("Hello, Python!")
if True:
print ("True")
else:
print ("False")
# 多行语句
total = item_one + \
item_two + \
item_three
# 字符串截取：变量[头下标:尾下标:步长]
str='123456789'
print(str) # 输出字符串123456789
print(str[0:-1]) # 输出第一个到倒数第二个的所有字符12345678
print(str[0]) # 输出字符串第一个字符1
print(str[2:5]) # 输出从第三个开始到第五个的字符345遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。
print(str[2:]) # 输出从第三个开始后的所有字符3456789
print(str[1:5:2]) # 输出从第二个开始到第五个且每隔一个的字符（步长为2）24
print(str * 2) # 输出字符串两次
print(str + '你好') # 连接字符串
print('------------------------------')
print('hello\nrunoob') # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob') # 在字符串前面添加一个 r，表示原始字符串，不会发生转义hello\nrunoob
input("\n\n按下 enter 键后退出。")
import sys; x = 'runoob'; sys.stdout.write(x + '\n')
if expression :
suite
elif expression :
suite
else :
suite
将整个模块(somemodule)导入，格式为： import somemodule
从某个模块中导入某个函数,格式为： from somemodule import somefunction
从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入，格式为： from somemodule import *
a = b = c = 1
a, b, c = 1, 2, "runoob"
基本数据类型
Python3 中有六个标准的数据类型：
Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）
isinstance 和 type 的区别在于：
type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。
>>> a = 111
>>> isinstance(a, int)
True
>>> issubclass(bool, int)
True
>>> True==1
True
>>> False==0
True
>>> True+1
2
>>> False+1
1
>>> 1 is True
False
>>> 0 is False
False
>>> 5 + 4 # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7 # 乘法
21
>>> 2 / 4 # 除法，得到一个浮点数..
0.5
>>> 2 // 4 # 除法，得到一个整数。。向下取接近商的整数
0
>>> 17 % 3 # 取余
2
>>> 2 ** 5 # 乘方
32
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
print (list) # 输出完整列表['abcd', 786, 2.23, 'runoob', 70.2]
print (list[0]) # 输出列表第一个元素abcd
print (list[1:3]) # 从第二个开始输出到第三个元素[786, 2.23]
print (list[2:]) # 输出从第三个元素开始的所有元素[2.23, 'runoob', 70.2]
print (tinylist * 2) # 输出两次列表[123, 'runoob', 123, 'runoob']
print (list + tinylist) # 连接列表['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']
>>> a = [1, 2, 3, 4, 5, 6]
>>> a[0] = 9
>>> a[2:5] = [13, 14, 15]
>>> a
[9, 2, 13, 14, 15, 6]
>>> a[2:5] = [] # 将对应的元素值设置为 []
>>> a
[9, 2, 6]
'I like runoob'.split(" ") #['I','like','runoob']
inputWords=inputWords[-1::-1]#['runoob','like','I']
' '.join(inputWords)# runoob like I
List列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。与字符串一样，元组的元素不能修改。
tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )
tinytuple = (123, 'runoob')
print (tuple) # 输出完整元组('abcd', 786, 2.23, 'runoob', 70.2)
print (tuple[0]) # 输出元组的第一个元素abcd
print (tuple[1:3]) # 输出从第二个元素开始到第三个元素(786, 2.23)
print (tuple[2:]) # 输出从第三个元素开始的所有元素(2.23, 'runoob', 70.2)
print (tinytuple * 2) # 输出两次元组(123, 'runoob', 123, 'runoob')
print (tuple + tinytuple) # 连接元组('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')
Set（集合）使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}
print(sites) # 输出集合，重复的元素被自动去掉{'Zhihu', 'Baidu', 'Taobao', 'Runoob', 'Google', 'Facebook'}
# 成员测试
if 'Runoob' in sites :
print('Runoob 在集合中')
else :
print('Runoob 不在集合中')
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)#{'b', 'c', 'a', 'r', 'd'}
print(a - b) # a 和 b 的差集{'r', 'b', 'd'}
print(a | b) # a 和 b 的并集{'b', 'c', 'a', 'z', 'm', 'r', 'l', 'd'}
print(a & b) # a 和 b 的交集{'c', 'a'}
print(a ^ b) # a 和 b 中不同时存在的元素{'z', 'b', 'm', 'r', 'l', 'd'}
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2] = "2 - 菜鸟工具"
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
print (dict['one']) # 输出键为 'one' 的值
print (dict[2]) # 输出键为 2 的值
print (tinydict) # 输出完整的字典
print (tinydict.keys()) # 输出所有键dict_keys(['name', 'code', 'site'])
print (tinydict.values()) # 输出所有值dict_values(['runoob', 1, 'www.runoob.com'])
>>> dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{'Runoob': 1, 'Google': 2, 'Taobao': 3}
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
>>> dict(Runoob=1, Google=2, Taobao=3)
{'Runoob': 1, 'Google': 2, 'Taobao': 3}
aTuple = (123, 'Google', 'Runoob', 'Taobao')
list1 = list(aTuple)
print ("列表元素 : ", list1)#列表元素 : [123, 'Google', 'Runoob', 'Taobao']
str="Hello World"
list2=list(str)
print ("列表元素 : ", list2)#列表元素 : ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']
>>>ord('a')
97
>>> ord('b')
98
>>> ord('c')
99
>>> print chr(48), chr(49), chr(97) # 十进制0 1 a
>>> a= 'www'
>>> b=tuple(a)
>>> b
('w', 'w', 'w')
>>> a={'www':123,'aaa':234}
>>> b=tuple(a)
>>> b
('www', 'aaa') # 将字段转换为元组时，只保留键！
>>> a=set('abcd')
>>> print (a)
{'c', 'd', 'b', 'a'}
>>> b=tuple(a)
>>> b
('c', 'd', 'b', 'a')
>>>s = 'RUNOOB'
>>> str(s)
'RUNOOB'
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> str(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"
>>>int() # 不传入参数时，得到结果0
0
>>> int(3)
3
>>> int(3.6)
3
>>> int('12',16) # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制
18
>>> int('0xa',16)
10
>>> int('10',8)
8
>>>
num_int = 123
num_str = "456"
print("Data type of num_int:",type(num_int))
# TypeError: unsupported operand type(s) for +: 'int' and 'str'整型和字符串类型运算结果会报错，输出 TypeError
int() 强制转换为整型
float() 强制转换为浮点型
str() 强制转换为字符串类型
推导式
>>> multiples = [i for i in range(30) if i % 3 == 0]
>>> print(multiples)
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
listdemo = ['Google','Runoob', 'Taobao']
# 将列表中各字符串值为键，各字符串的长度为值，组成键值对
>>> newdict = {key:len(key) for key in listdemo}
>>> newdict
{'Google': 6, 'Runoob': 6, 'Taobao': 6}
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'d', 'r'}
>>> type(a)
<class 'set'>
>>> a = (x for x in range(1,10))
>>> a
<generator object <genexpr> at 0x7faf6ee20a50> # 返回的是生成器对象
>>> tuple(a) # 使用 tuple() 函数，可以直接将生成器对象转换成元组
(1, 2, 3, 4, 5, 6, 7, 8, 9)
运算符
比较运算符：==、!=、>、<、>=、<=
赋值运算符: =、+=、-=、*=、/=、%=、**=、//=、:=
#海象运算符，可在表达式内部为变量赋值。Python3.8 版本新增运算符。
if (n := len(a)) > 10:
print(f"List is too long ({n} elements, expected <= 10)")
# 位运算符
a = 0011 1100
b = 0000 1101
-----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011
a << 2 1111 0000
a >> 2 0000 1111
逻辑运算符：
x and y 布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。
x or y 布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。
not x 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。
成员运算符：
in 如果在指定的序列中找到值返回 True，否则返回 False。
not in 如果在指定的序列中没有找到值返回 True，否则返回 False。
身份运算符：
is 是判断两个标识符是不是引用自一个对象
is not 是判断两个标识符是不是引用自不同对象
is 与 == 区别：
is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
>>>a = [1, 2, 3]
>>> b = a
>>> b is a
True
>>> b == a
True
>>> b = a[:]
>>> b is a
False
>>> b == a
True
优先级：
& 位 ‘AND’
^ | 位运算符
is is not 身份运算符
in not in 成员运算符
not and or 逻辑运算符
数字(Number)
您可以通过使用del语句删除单个或多个对象的引用，例如：
del var
del var_a, var_b
abs(x) 返回数字的绝对值，如abs(-10) 返回 10
ceil(x) 返回数字的上入整数，如math.ceil(4.1) 返回 5
floor(x) 返回数字的下舍整数，如math.floor(4.9)返回 4
log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0
max(x1, x2,…) 返回给定参数的最大值，参数可以为序列。
min(x1, x2,…) 返回给定参数的最小值，参数可以为序列。
pow(x, y) x**y 运算后的值。
round(x [,n])
返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。
其实准确的说是保留值将保留到离上一位更近的一端。
sqrt(x) 返回数字x的平方根。
choice(seq) 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
random() 随机生成下一个实数，它在[0,1)范围内。
shuffle(lst) 将序列的所有元素随机排序
import random
list = [20, 16, 10, 5];
random.shuffle(list)
print ("随机排序列表 : ", list)#随机排序列表 : [20, 5, 16, 10]
数学常量: pi、e
字符串
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
>>> name = 'Runoob'
>>> f'Hello {name}' # 替换变量
'Hello Runoob'
>>> f'{1+2}' # 使用表达式
'3'
>>> w = {'name': 'Runoob', 'url': 'www.runoob.com'}
>>> f'{w["name"]}: {w["url"]}'
'Runoob: www.runoob.com'
str.capitalize()
str = "[runoob]"
print ("str.center(40, '*') : ", str.center(40, '*')) # str.center(40, '*') : ****************[runoob]****************
str="www.runoob.com"
str.count('o') : 3
str.count('run', 0, 10) : 1
#str.endswith(suffix[, start[, end]])
print('01234'.endswith('234', 0, 4))
>>> False
print('01234'.endswith('234', 0, 5))
>>> True
>>> print(info.find('a', 1)) # 从下标1开始，查找在字符串里第一个出现的子串：返回结果3
3
>>> print(info.find('3')) # 查找不到返回-1
-1
str.isalnum()
str.isalpha()
str.isdigit()
str.islower()
str.isupper()
str.lower()
str.upper()
str.swapcase();
str.isspace()
str.title();
str.istitle()
len(str)
s1 = "-"
s2 = ""
seq = ("r", "u", "n", "o", "o", "b") # 字符串序列
print (s1.join( seq ))# r-u-n-o-o-b
print (s2.join( seq ))
str = "Runoob example....wow!!!"
print (str.ljust(50, '*'))# Runoob example....wow!!!**************************
str = " this is string example....wow!!! ";
print( str.lstrip() );
str = "88888888this is string example....wow!!!8888888";
print( str.lstrip('8') );# this is string example....wow!!!8888888
str = "runoob"
print ("最大字符: " + max(str))# u
str = "this is string example....wow!!!"
print (str.replace("is", "was", 3))# thwas was string example....wow!!!
str = "this is string example....wow!!!"
print (str.split( )) # 以空格为分隔符 ['this', 'is', 'string', 'example....wow!!!']
print (str.split('i',1)) # 以 i 为分隔符['th', 's is string example....wow!!!']
#请注意，非字母后的第一个字母将转换为大写字母：
txt = "hello b2b2b2 and 3g3g3g"
x = txt.title()
print(x)# Hello B2B2B2 And 3G3G3G
str = "runoob2016"
print (str.isdecimal())# False
str = "23443434"
print (str.isdecimal())# True
str = "this is string example from runoob....wow!!!"
print ("str.zfill : ",str.zfill(50))# str.zfill : 000000this is string example from runoob....wow!!!
intab = "aeiou"
outtab = "12345"
trantab = str.maketrans(intab, outtab) # 制作翻译表
str = "this is string example....wow!!!"
print (str.translate(trantab))
capitalize() 将字符串的第一个字符转换为大写
center(width, fillchar)返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回 True，否则返回 False
startswith() 方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。
find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果指定范围内如果包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回-1。
rfind() 返回字符串最后一次出现的位置，如果没有匹配项则返回-1。
index()跟find()方法一样，只不过如果str不在字符串中会报一个异常。
rindex() 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，你可以指定可选参数[beg:end]设置查找的区间。
isalnum() 方法检测字符串是否由字母和数字组成
isalpha() 方法检测字符串是否只由字母或文字组成。
isdigit() 方法检测字符串是否只由数字组成。
islower() 方法检测字符串是否由小写字母组成。
isupper() 方法检测字符串中所有的字母是否都为大写。
isspace() 方法检测字符串是否只由空白字符组成。
len() 方法返回对象（字符、列表、元组等）长度或项目个数。
join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。
ljust() 方法返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
rjust() 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串
lower() 方法转换字符串中所有大写字符为小写。
upper() 方法将字符串中的小写字母转为大写字母。
swapcase() 方法用于对字符串的大小写字母进行转换，即将大写字母转换为小写字母，小写字母会转换为大写字母。
lstrip() 方法用于截掉字符串左边的空格或指定字符。
rstrip() 删除 string 字符串末尾的指定字符，默认为空白符，包括空格、换行符、回车符、制表符。
strip() 方法用于移除字符串头尾指定的字符（默认为空格）或字符序列。
max() 方法返回字符串中最大的字母。
min() 方法返回字符串中最小的字母。
replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。
split() 通过指定分隔符对字符串进行切片，如果第二个参数 num 有指定值，则分割为 num+1 个子字符串。
title() 方法返回"标题化"的字符串,就是说所有单词的首个字母转化为大写，其余字母均为小写
istitle() 方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。
isdecimal() 方法检查字符串是否只包含十进制字符。
zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充0。
maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
列表
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
>>>a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
list = ['Google', 'Runoob', 1997, 2000]
del list[2]
print ("删除第三个元素 : ", list)#['Google', 'Runoob', 2000]
list() 方法用于将元组或字符串转换为列表。
len() 方法返回列表元素个数。
max() 方法返回列表元素中的最大值。
min() 方法返回列表元素中的最小值。
append() 方法用于在列表末尾添加新的对象。
count() 方法用于统计某个元素在列表中出现的次数。
extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。元素列表，可以是列表、元组、集合、字典，若为字典,则仅会将键(key)作为元素依次添加至原列表的末尾。
index() 函数用于从列表中找出某个值第一个匹配项的索引位置。list.index(x[, start[, end]])
insert() 函数用于将指定对象插入列表的指定位置。
pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。list.pop([index=-1])
list.popleft()
remove() 函数用于移除列表中某个值的第一个匹配项。
reverse() 函数用于反向列表中元素。
sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。list.sort( key=None, reverse=False)
list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
aList = [123, 'Google', 'Runoob', 'Taobao', 123];
print ("123 元素个数 : ", aList.count(123))
list1 = ['Google', 'Runoob', 'Taobao']
list1.insert(1, 'Baidu')
print ('列表插入元素后为 : ', list1)# 列表插入元素后为 : ['Google', 'Baidu', 'Runoob', 'Taobao']
list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
list1.remove('Taobao')
print ("列表现在为 : ", list1)#['Google', 'Runoob', 'Baidu']
list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
list1.reverse()# 没返回值
print ("列表反转后: ", list1)# 列表反转后: ['Baidu', 'Taobao', 'Runoob', 'Google']
# 列表
vowels = ['e', 'a', 'u', 'o', 'i']
# 降序
vowels.sort(reverse=True)
# 输出结果
print ( '降序输出:', vowels )# ['u', 'o', 'i', 'e', 'a']
# 获取列表的第二个元素
def takeSecond(elem):
return elem[1]
# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
# 指定第二个元素排序
random.sort(key=takeSecond)
# 输出类别
print ('排序列表：', random)# 排序列表：[(4, 1), (2, 2), (1, 3), (3, 4)]
元组
元组的元素不能修改
>>> tup1 = ('Google', 'Runoob', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d" # 不需要括号也可以
>>> type(tup3)
<class 'tuple'>
#元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用
>>> tup1 = (50)
>>> type(tup1) # 不加逗号，类型为整型
<class 'int'>
>>> tup1 = (50,)
>>> type(tup1) # 加上逗号，类型为元组
<class 'tuple'>
>>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
>>> tuple1=tuple(list1)
>>> tuple1
('Google', 'Taobao', 'Runoob', 'Baidu')
字典
emptyDict = dict()
emptyDict = {}
len(emptyDict) # 0
print(type(emptyDict))# <class 'dict'>
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print ("tinydict['Name']: ", tinydict['Name'])# Runoob
print ("tinydict['Alice']: ", tinydict['Alice'])# 如果用字典里没有的键访问数据，会输出错误
tinydict['Age'] = 8
del tinydict['Name'] # 删除键 'Name'
tinydict.clear() # 清空字典
del tinydict # 删除字典
键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
len(dict)计算字典元素个数，即键的总数。
str(dict)输出字典，可以打印的字符串表示。
type(variable)返回输入的变量类型，如果变量是字典就返回字典类型。
dict.clear()删除字典内所有元素
dict.copy()返回一个字典的浅复制
fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。
get() 函数返回指定键的值。
dict.keys()、dict.values() 和 dict.items() 返回的都是视图对象，不能对视图对象进行任何的修改，因为字典的视图对象都是只读的。
setdefault() 如果键不存在于字典中，将会添加键并将值设为默认值。
update() 函数把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。
pop() 方法删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
popitem() 方法随机返回并删除字典中的最后一对键和值。如果字典已经为空，却调用了此方法，就报出KeyError异常。
>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> str(tinydict)
"{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"
dict1 = {'user':'runoob','num':[1,2,3]}
dict2 = dict1 # 浅拷贝: 引用对象
dict3 = dict1.copy() # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，子对象是引用
seq = ('name', 'age', 'sex')
tinydict = dict.fromkeys(seq)
print ("新的字典为 : %s" % str(tinydict))# 新的字典为 : {'age': None, 'name': None, 'sex': None}
tinydict = dict.fromkeys(seq, 10)
print ("新的字典为 : %s" % str(tinydict))# 新的字典为 : {'age': 10, 'name': 10, 'sex': 10}
tinydict = {'Name': 'Runoob', 'Age': 27}
print ("Age : ", tinydict.get('Age'))# 27
# 没有设置 Sex，也没有设置默认的值，输出 None
print ("Sex : ", tinydict.get('Sex')) # None
# 没有设置 Salary，输出默认的值 0.0
print ('Salary: ', tinydict.get('Salary', 0.0))# 0.0
tinydict = {'RUNOOB' : {'url' : 'www.runoob.com'}}
res = tinydict.get('RUNOOB', {}).get('url')
#dict[key]，key不在字典中时，会触发KeyError异常
tinydict = {'Name': 'Runoob', 'Age': 7}
print ("Value : %s" % tinydict.items())# Value : dict_items([('Age', 7), ('Name', 'Runoob')])
>>>phone_book={'sam':'1234','tom':'5678'} //创建字典
>>>phone_book.keys() //调用keys方法
dict_keys(['sam', 'tom'])
tinydict = {'Name': 'Runoob', 'Age': 7}
print ("Age 键的值为 : %s" % tinydict.setdefault('Age', None))# 7
print ("Sex 键的值为 : %s" % tinydict.setdefault('Sex', None))# None
print ("新字典为：", tinydict)# {'Age': 7, 'Name': 'Runoob', 'Sex': None}
tinydict = {'Name': 'Runoob', 'Age': 7}
tinydict2 = {'Sex': 'female' }
tinydict.update(tinydict2)
print ("更新字典 tinydict : ", tinydict)# {'Name': 'Runoob', 'Age': 7, 'Sex': 'female'}
#pop(key[,default])
>>> site= {'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'}
>>> pop_obj=site.pop('name')
>>> print(pop_obj)
菜鸟教程
print(site.pop(3,"nokey")); # 设置默认值，必须添加，否则报错
site= {'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'}
pop_obj=site.popitem()
print(pop_obj) #('url', 'www.runoob.com')
print(site)# {'name': '菜鸟教程', 'alexa': 10000}
集合
集合（set）是一个无序的不重复元素序列。
>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}
add() 为集合添加元素
clear() 移除集合中的所有元素
copy() 拷贝一个集合
difference() 返回多个集合的差集，即返回的集合元素包含在第一个集合中，但不包含在第二个集合(方法的参数)中
difference_update() 移除集合中的元素，该元素在指定的集合也存在。
discard() 删除集合中指定的元素,因为 remove() 方法在移除一个不存在的元素时会发生错误，而 discard() 方法不会。
intersection() 返回集合的交集set.intersection(set1, set2 … etc)
intersection_update() 返回集合的交集。
isdisjoint() 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset() 判断指定集合是否为该方法参数集合的子集。
issuperset() 判断该方法的参数集合是否为指定集合的子集
pop() 随机移除元素
remove() 移除指定元素
symmetric_difference() 返回两个集合中不重复的元素集合。
symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union() 返回两个集合的并集set.union(set1, set2…)
update() 给集合添加元素
fruits = {"apple", "banana", "cherry"}
fruits.add("orange")
fruits.clear()
fruits.copy()
fruits.pop()
fruits.remove("banana") # 不存在会发生错误
fruits.discard("banana") # 不存在不会发生错误
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
x.update(y)
print(x)# {'banana', 'apple', 'google', 'runoob', 'cherry'}
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
z = x.difference(y) # 返回一个集合，元素包含在集合 x ，但不在集合 y
print(z)# {'cherry', 'banana'}
x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
x.difference_update(y) # 移除两个集合都包含的元素
print(x)# {'cherry', 'banana'}
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
z = x.intersection(y)
print(z)# {'apple'}
x.intersection_update(y)
print(x) # {'apple'}
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "facebook"}
z = x.isdisjoint(y)
print(z)# True
x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b", "a"}
z = x.issubset(y)
print(z)# True
x = {"f", "e", "d", "c", "b", "a"}
y = {"a", "b", "c"}
z = x.issuperset(y)
print(z)# True
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
z = x.symmetric_difference(y)
print(z)# {'google', 'cherry', 'banana', 'runoob'}
x.symmetric_difference_update(y)
print(x) # {'google', 'cherry', 'banana', 'runoob'}
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
z = x.union(y)
print(z)# {'cherry', 'runoob', 'google', 'banana', 'apple'}
循环语句
count = 0
while count < 5:
print (count, " 小于 5")
count = count + 1
else:
print (count, " 大于或等于 5")
sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
if site == "Runoob":
print("菜鸟教程!")
break
print("循环数据 " + site)
else:
print("没有循环数据!")
print("完成循环!")
>>>for i in range(5):
... print(i)
...
0
1
2
3
4
>>>for i in range(5,9) :
print(i)
5
6
7
8
>>>for i in range(0, 10, 3) :
print(i)
0
3
6
9
>>>
break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。
continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。
函数
可更改(mutable)与不可更改(immutable)对象
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。
可变类型：变量赋值 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 printme( str ):
"打印任何传入的字符串"
print (str)
return
# 调用 printme 函数，不加参数会报错
printme()
printme( str = "菜鸟教程")
def printinfo( name, age = 35 ):
"打印任何传入的字符串"
print ("名字: ", name)
print ("年龄: ", age)
return
#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)# 70
print (vartuple)# (60,50)
# 调用printinfo 函数
printinfo( 70, 60, 50 )
def printinfo( arg1, **vardict ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)#1
print (vardict)#{'a': 2, 'b': 3}
# 调用printinfo 函数
printinfo(1, a=2,b=3)
使用 lambda 来创建匿名函数。lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))# 30
print ("相加后的值为 : ", sum( 20, 20 ))# 40
模块
#support.py 文件代码
def print_func( par ):
print ("Hello : ", par)
return
# 导入模块
import support
# 现在可以调用模块里包含的函数了
support.print_func("Runoob")
每个模块都有一个__name__属性，当其值是__main__时，表明该模块自身在运行，否则是被引入。
if __name__ == '__main__':
print('程序自身在运行')
else:
print('我来自另一模块')
内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回:
>>> import fibo, sys
>>> dir(fibo)
['__name__', 'fib', 'fib2']
dir() # 得到一个当前模块中定义的属性列表
输入输出
>>> print('{0} 和 {1}'.format('Google', 'Runoob'))
Google 和 Runoob
>>> print('{1} 和 {0}'.format('Google', 'Runoob'))
Runoob 和 Google
>>> print('站点列表 {0}, {1}, 和 {other}。'.format('Google', 'Runoob', other='Taobao'))
站点列表 Google, Runoob, 和 Taobao。
str = input("请输入：");
print ("你输入的内容是: ", str)
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
# 打开一个文件
f = open("/tmp/foo.txt", "w")
f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )
str = f.read()
print(str)
# 关闭打开的文件
f.close()
错误和异常
面向对象
#类定义
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('runoob',10,30)
p.speak()
class DerivedClassName(Base1, Base2, Base3):#继承
__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。
class JustCounter:
__secretCount = 0 # 私有变量
publicCount = 0 # 公开变量
def count(self):
self.__secretCount += 1
self.publicCount += 1
print (self.__secretCount)
counter = JustCounter()
命名空间和作用域
>>> if True:
... msg = 'I am from Runoob'
...
>>> msg
'I am from Runoob'
>>>
当内部作用域想修改外部作用域的变量时，就要用到 global 和 nonlocal 关键字了。
num = 1
def fun1():
global num # 需要使用 global 关键字声明
print(num) #1
num = 123
print(num)# 123
fun1()
print(num)#123
如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了
def outer():
num = 10
def inner():
nonlocal num # nonlocal关键字声明
num = 100
print(num)#100
inner()
print(num)#100
outer()
正则表达式
re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。
re.search 扫描整个字符串并返回第一个成功的匹配。
import re
line = "Cats are smarter than dogs"
matchObj = re.match( r'dogs', line, re.M|re.I) # None
matchObj = re.search( r'dogs', line, re.M|re.I)
print ("search --> matchObj.group() : ", matchObj.group())# dogs
import re
result1 = re.findall(r'\d+','runoob 123 google 456')
print(result1)# ['123', '456']
result = re.findall(r'(\w+)=(\d+)', 'set width=20 and height=10')
print(result)#[('width', '20'), ('height', '10')]
JSON
json.dumps(): 对数据进行编码。
json.loads(): 对数据进行解码。
import json
# Python 字典类型转换为 JSON 对象
data1 = {
'no' : 1,
'name' : 'Runoob',
'url' : 'http://www.runoob.com'
}
json_str = json.dumps(data1)
# 将 JSON 对象转换为 Python 字典
data2 = json.loads(json_str)
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象
all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。元素除了是 0、空、None、False 外都算 True。
setattr() 函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的。
def is_odd(n):
return n % 2 == 1
tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist)# [1, 3, 5, 7, 9]
>>> all(['a', 'b', 'c', 'd']) # 列表list，元素都不为空或0
True
>>> all(['a', 'b', '', 'd']) # 列表list，存在一个为空的元素
False
>>> all([]) # 空列表
True
>>> all(()) # 空元组
True
>>>class A(object):
... bar = 1
...
>>> a = A()
>>> getattr(a, 'bar') # 获取属性 bar 值
1
>>> setattr(a, 'bar', 5) # 设置属性 bar 值
>>> a.bar
5
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
