python基础知识速刷

import

• import modulename 导入整个模块
• from modulename import xx 从某个模块导入部分内容

import keyword
from sys import argv,path
from sys import *

保留字

python提供了keyword库，可以查看所有的保留字

import keyword
print(keyword.kwlist)

['False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert', 'async', 'await', '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']

注释

# 单行注释 

''' 
多行注释1
''' 

""" 
多行注释2
"""

行与缩进

代码块使用缩进控制，而不是{}，缩进格数保持一致

if xx:
    print ("Answer")
    print ("True")
else:
    print ("Answer")
  print ("False")    # 缩进格数与上面不一致，运行错误

多行语句

一条语句如果太长，可以写成多行，行末用 \ 连接

y = 1 + \
    2 + \
    3

如果是[] {} ()三种括号，不用\连接，直接回车换行

控制台打印

print("Hello, World!")

单行多语句

在同一行写多条语句，用分好;隔开

x = 1; y = 2; z = '22'

变量

• 变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建
• 变量没有类型
• 等号（=）用来给变量赋值,等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值

x = 1;
y = 2;
z = '22'

声明多个变量及赋值

x = y = z = 1
a,b,c = 1,'2',1.0

del 删除对象引用

x = y = z = 1
del x,y

数据类型

Python3 的六个标准数据类型中：

• 不可变数据（3 个）：
  • Number（数字）
  • String（字符串）
  • Tuple（元组）；
• 可变数据（3 个）：
  • List（列表）
  • Dictionary（字典）
  • Set（集合）。

数字类型

python中数字有四种类型：整数、布尔型、浮点数和复数

x = 1
y = 1.0
z = True  # False,bool 是 int 的子类，True 和 False 可以和数字相加， True==1、False==0 会返回 **True**，但可以通过 is 来判断类型。
w = 1 + 2j

数值运算

print(1+1)
print(1-1)
print(2*3)
print(1/2)  #  0.5除法，得到小数
print(1//2)  # 0   除法，取整，不四舍五入
print(5%2)  # 1  取余
print(2**3)  # 8   指数

字符串类型

中单引号 ' 和双引号 " 使用完全相同，但是要成对儿使用。 python中没有字符类型，单个字符也是字符串

x = 'a'
y = "b"
z = x + y   # ab，字符串连接
w = x * 3   # aaa，*表示重复几次

字符串访问，索引：

• 正向索引,从0开始 ：0,1,2,3,...,n-1
• 反向索引，从-1开始：-n,...,-4,-3,-2,-1

str = '123456789'

print(str)  # 输出字符串
print(str[0:-1])  # 输出第一个到倒数第二个的所有字符
print(str[0])  # 输出字符串第一个字符
print(str[2:5])  # 输出从第三个开始到第五个的字符
print(str[2:])  # 输出从第三个开始后的所有字符
print(str[1:5:2])  # 输出从第二个开始到第五个且每隔一个的字符（步长为2）
print(str * 2)  # 输出字符串两次
print('1' in str)
print('1' not in str)

转义字符

print('hello\nrunoob')  # 使用反斜杠()+n转义特殊字符
print(r'hello\nrunoob')  # 在字符串前面添加一个 r，表示原始字符串，不会发生转义

输出：
hello
runoob
hello\nrunoob

字符串格式化

print ("我叫 %s 今年 %d 岁!" % ('小明', 10))  # 字符串格式化 

• %c 格式化字符及其ASCII码
• %s 格式化字符串
• %d 格式化整数
• %u 格式化无符号整型
• %o 格式化无符号八进制数
• %x 格式化无符号十六进制数
• %X 格式化无符号十六进制数（大写）
• %f 格式化浮点数字，可指定小数点后的精度
• %e 用科学计数法格式化浮点数
• %E 作用同%e，用科学计数法格式化浮点数
• %g %f和%e的简写
• %G %f 和 %E 的简写
• %p 用十六进制数格式化变量的地址

f-string

格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去

name = "zhangs"
print(f"hello {name}")

字符串方法：

name = "ab cab cABC  "
print(name.capitalize())  #Ab cab cabc,字符串第一个字符大写
print(name.center(20,"*"))  #***ab cab cABC  ****,返回一个指定的宽度width局中的字符串，第二个参数是填充的字符，不传默认空格
print(name.count("a",1,7))  #1,返回指定字符在字符串中出现的次数，第二三个参数用于指定范围
encode_name = name.encode("UTF-8")  #编码utf-8
print(encode_name)  # b'ab cab cABC  '
print(encode_name.decode("UTF-8","strict"))  #ab cab cABC   用于解码
print(name.endswith("c",2,7))  #False  指定范围内，检测是否以指定字符结尾
print(name.startswith("c",2,7))  #False  检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
print(name.expandtabs(8))  #ab cab cABC  把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。
print(name.find("c",0,5))  #3  检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
print(name.rfind("c", 0, 5))  #3  类似于 find()函数，不过是从右边开始查找.

print(name.index("c",0,5))  #3  跟find()方法一样，只不过如果str不在字符串中会报一个异常。
print(name.rindex("c", 0, 9))  #7  类似于 index()，不过是从右边开始.
name1 = "124abc"
print(name1.isalnum())  #True  如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False
name2 = "124中问"
print(name2.isalpha())  #False  如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False
name3 = "124"
print(name.isdigit())  #False  如果字符串只包含数字则返回 True 否则返回 False..
print(name.islower())  #False   如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
print(name.isnumeric())  #False   如果字符串中只包含数字字符，则返回 True，否则返回 False
name4 = "    "
print(name4.isspace())  #True  如果字符串中只包含空白，则返回 True，否则返回 False.
name5 = "This Is Title"
print(name5.istitle())  #True  如果字符串中所有的单词拼写首字母是否为大写，且其他字母为小写则返回 True，否则返回 False.
name10 = "this is title"
print(name10.title())  #This Is Title  返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
name6 = "LISI"
print(name6.isupper())  #True  如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
s1 = "-"
s2 = ""
seq = ("a", "b", "c", "d")  # 字符串序列
print(s1.join(seq))  # a-b-c-d,返回通过指定字符连接序列中元素后生成的新字符串。
print(s2.join(seq))  # abcd

print(len(name))  #13  返回字符串长度
print(name.ljust(20,"*"))  #ab cab cABC  *******    返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
print(name.rjust(20, "*"))  #*******ab cab cABC    返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串
print(name.zfill(20))  #0000000ab cab cABC    返回长度为 width 的字符串，原字符串右对齐，前面填充0
print(name.lower())  #ab cab cabc   返回将字符串中所有大写字符转换为小写后生成的字符串。
print(name.upper())  #AB CAB CABC   返回将字符串中所有小写字符转换为大写后生成的字符串。
print(name.swapcase())  #AB CAB Cabc   将字符串中大写转换为小写，小写转换为大写
print(name.lstrip(" "))  #ab cab cABC  截掉字符串左边的空格或指定字符。
print(name.rstrip(" "))  #ab cab cABC  删除字符串末尾的空格或指定字符。
print(name.strip(" "))   #ab cab cABC  在字符串上执行 lstrip()和 rstrip()
print(max(name))  #c返回字符串中最大的字母
print(min(name))  #   返回字符串中最小的字母
print(name.replace("a","z",4))  #zb czb cABC   把 将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。
print(name.split(" ",3))  #['ab', 'cab', 'cABC', ' ']  以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串
print(name.splitlines())  #['ab cab cABC  ']  按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

intab = "aeiou"
outtab = "12345"
trantab = str.maketrans(intab, outtab)  # 制作翻译表
print(name.translate(trantab))  #1b c1b cABC    返回翻译后的字符串,若给出了 delete 参数，则将原来的bytes中的属于delete的字符删除，剩下的字符要按照table中给出的映射来进行映射 。
print(name.isdecimal())  #False   检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

列表List

索引：

• 正向索引,从0开始 ：0,1,2,3,...,n-1
• 反向索引，从-1开始：-n,...,-4,-3,-2,-1

print(list)  # 输出完整列表
print(list[0])  # 输出列表第一个元素
print(list[1:3])  # 从第二个开始输出到第三个元素
print(list[2:])  # 输出从第三个元素开始的所有元素
print(list2 * 3)  # 输出三次列表
print(list + list2)  # 连接列表

输出：
[1, 2.3, 'abc', 'hello', 4.3j]
1
[2.3, 'abc']
['abc', 'hello', 4.3j]
['xxx', 'yyy', 'xxx', 'yyy', 'xxx', 'yyy']
[1, 2.3, 'abc', 'hello', 4.3j, 'xxx', 'yyy']

列表函数：

• append 末尾添加元素

list1 = ["aaa","bbb","ccc","ddd","eee","fff"]
list1.append("ggg")   
print(list1)   #['aaa', 'bbb', 'ccc', 'ddd', 'eee', 'fff', 'ggg']  

• del 删除指定index的元素

list2 = ["aaa", "bbb", "ccc", "ddd", "eee", "fff"]
del list2[2]     
print(list2    #['aaa', 'bbb', 'ddd', 'eee', 'fff'] 

• remove 移除列表中某个值的第一个匹配项

list3 = ["aaa", "bbb", "ccc", "ddd", "ccc", "fff"]
list3.remove("ccc")    
print(list3)    #['aaa', 'bbb', 'ddd', 'ccc', 'fff'] 

• len 列表长度

list4 = ["aaa", "bbb", "ccc", "ddd", "ccc", "fff"]
print(len(list4))  #6   

• 加号 + 连接两个列表

list5 = ["aaa", "bbb", "ccc"]
list6 = ["ddd", "ccc", "fff"]
print(list5+list6)  #['aaa', 'bbb', 'ccc', 'ddd', 'ccc', 'fff']   

• 乘号 * 内容重复指定次数

list7 = ["ddd", "ccc"]
print(list7 * 4)  #['ddd', 'ccc', 'ddd', 'ccc', 'ddd', 'ccc', 'ddd', 'ccc']   

• in 是否包含元素

list17 = ["ddd", "ccc"]
print("ddd" in list17)  #True  

• for 迭代遍历

for x in list7:  
    print(x)

• eq 比较两个列的元素是否一一相等

a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a, b))  #False   
print("operator.eq(c,b): ", operator.eq(c, b))  #True

• max min 返回列表中最大、最小的元素

list8 = [1,2,3,4,5,6,7]
print(max(list8))  #7   返回列表中最大的元素
print(min(list8))  #1   返回列表中最小的元素

• list(tuple) 元组转为列表

tuple1 = (1,2,4,5,6)
print(list(tuple1))   #[1, 2, 4, 5, 6]   

• count 统计指定元素出现的次数

list9 = [1, 2, 3, 1, 5, 1, 7]
print(list9.count(1))   #3   

• extend 将指定的元组、集合，扩展到列表末

# 列表
language = ['French', 'English', 'German']
# 元组
language_tuple = ('Spanish', 'Portuguese')
# 集合
language_set = {'Chinese', 'Japanese'}
# 添加元组元素到列表末尾
language.extend(language_tuple)   #扩展元组
print('新列表: ', language)   #['French', 'English', 'German', 'Spanish', 'Portuguese']
# 添加集合元素到列表末尾
language.extend(language_set)  #扩展集合
print('新列表: ', language)  # ['French', 'English', 'German', 'Spanish', 'Portuguese', 'Japanese', 'Chinese']

• index 从列表中找出某个值第一个匹配项的索引位置

list10 = [1, 2, 3, 1, 5, 1, 7]
print(list10.index(3,2,6))  #2   从列表中找出某个值第一个匹配项的索引位置

• insert 在指定索引处插入元素

list11 = [1, 2, 3, 1, 5, 1, 7]
list11.insert(2,99)  #[1, 2, 99, 3, 1, 5, 1, 7]   在指定索引处插入元素
print(list11)

• pop 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

list11 = [1, 2, 99，3, 1, 5, 1, 7]
list11.pop(-2)  #
print(list11)   # [1, 2, 99, 3, 1, 5,  7] 

• reverse 列表翻转

list12 = [1, 2, 3, 4, 5, 6, 7]
list12.reverse()
print(list12)  #[7, 6, 5, 4, 3, 2, 1]    列表翻转

• sort 对列表元素排序

list13 = [ 2,1,4,5,3,8,3,3]
list13.sort()  #[1, 2, 3, 3, 3, 4, 5, 8]   对列表元素排序
print(list13)

# 获取列表的第二个元素
def takeSecond(elem):
    return elem[1]
# 列表
list14 = [(2, 2), (3, 4), (4, 1), (1, 3)]
# 指定第二个元素排序  reverse升序还是降序，True降序  False升序
list14.sort(key=takeSecond,reverse=True)    #  [(3, 4), (1, 3), (2, 2), (4, 1)]
# 输出类别
print('排序列表：', list14)

• clear 清空列表

list15 = [(2, 2), (3, 4), (4, 1), (1, 3)]
list15.clear()  #清空列表
print(list15)   # []

• copy 复制列表元素

list16 = [(2, 2), (3, 4), (4, 1), (1, 3)]
list17 = list16.copy()  #[(2, 2), (3, 4), (4, 1), (1, 3)]    
print(list17)

元组

• 元祖与列表类似，列表用[],元祖用（）
• 元组元素不能修改，即,不能进行tuple[1]=34的操作,列表可以list[1]=22

索引：

• 正向索引,从0开始 ：0,1,2,3,...,n-1
• 反向索引，从-1开始：-n,...,-4,-3,-2,-1

元组常用函数：

• 创建元组

tuple = ('aa', 1, 2.0, 3j)  # 创建元组  方式1
tuple2 = (123, 'bb')  # 创建元组  方式2
tuple3 = "a", "b", "c", "d"  # 创建元组   方式3
tuple4 = ()    # 空元组
tuple5 = (20,) # 一个元素，需要在元素后添加逗号
tuple6 = tuple + tuple2  # 使用两个现有元组创建一个新元组

• 元组元素访问

print(tuple)  # 输出完整元组
print(tuple[0])  # 输出元组的第一个元素
print(tuple[1:3])  # 输出从第二个元素开始到第三个元素
print(tuple[2:])  # 输出从第三个元素开始的所有元素


输出：
('aa', 1, 2.0, 3j)
aa
(1, 2.0)
(2.0, 3j)

• del 删除元组

tup = ('a', 'b', 1, 2)
print(tup)
del tup
# print("删除后的元组 tup : ")
# print(tup)  # 元组删除后，再打印会报错

• len 元组内元素个数

tup1 = ('a', 'b', 1, 2)
print(len(tup1))  #4

• 加号 + 将两个元组连接，建成一个新的元组

tup2 = ('a', 'b')
tup3 = (1, 2)
print(tup2 + tup3)  #('a', 'b', 1, 2)

• 乘号 * 元组内元素重复指定次数

tup4 = (1)
print(tup4 * 3)  # (1,1,1)

• in 判断元素是否包含在元组中

tup5 = ('a', 'b', 1, 2)
print(1 in tup5)  # True

• for 元组遍历

tup6 = ('a', 'b', 1, 2)
for x in tup6 :
    print(x)

• max min 返回元组中最大、最小元素

tup7 = (1, 2, 3, 4)
print(max(tup7))  #4
print(min(tup7))  #1

• tuple(list) 将list转为元组

list8 = [1,2,3,4,5]
print(tuple(list8))  #(1,2,3,4,5)

Set集合

• 创建集合

site1 = ()  # 创建空集合
site2 = set("a")  #方式1：创建一个集合
sites = {'a', 'b', 'c', 'a', 'b', 'f'}  #方式二：创建一个集合
#set2 = {} #错误，这是一个字典
set3 = set()  #创建一个空集合
set0 = set(("a", "b", "c"))  #用元组创建一个set

• 去除重复

set4 = {"a", "b", "c", "a", "b"}
print(set4)  # {'a', 'b', 'c'}

• add 添加

set5 = {"a", "b", "c"}
set5.add("d")
print(set5)  # {'a', 'd', 'b', 'c'}

• update更新,可以是列表、元组、字典

set5 = {"a", "b", "c"}
list = [1,2]
tup = (3,4)
dict = {'key1':'value1'}
set5.update(list)
set5.update(tup)
set5.update(dict)  # 字典取key
print(set5)  # {1, 2, 3, 4, 'a', 'key1', 'c', 'b'}

*

# remove 移除元素
set6 = {"a", "b", "c"}
set6.remove("a")  # 不存在会报错
set6.discard("d")  # 不存在不会报错
set6.pop()  # 随机删除一个元素
print(set6)  # {'c'}

• clear 集合清空

set8 = {"a", "b", "c"}
set8.clear()  # 集合清空
print(set8)  # set()

• len 集合长度

set7 = {"a", "b", "c"}
print(len(set7))  # 3

• 集合间运算

# 成员测试
if 'a' in sites:
    print('hello')
else:
    print('hi')

# set可以进行集合运算
a = set('abcd')
b = set('cdef')

print(a)
print(a - b)  # a 和 b 的差集
print(a | b)  # a 和 b 的并集
print(a & b)  # a 和 b 的交集
print(a ^ b)  # a 和 b 中不同时存在的元素

• in 判断元素是否在集合中

set9 = {"a", "b", "c"}
print("a" in set9)  # True

• difference() 返回多个集合的差集，自身集合没变化

set10 = {"a", "b", "c"}
set11 = {"b", "c", "d"}
print(set10.difference(set11))  # {'a'}

• difference_update() 移除集合中的元素，该元素在指定的集合也存在。改变了自身集合

set12 = {"a", "b", "c"}
set13 = {"b", "c", "d"}
set12.difference_update(set13)
print(set12)   # {'a'}

• intersection() 返回集合的交集

set14 = {"a", "b", "c"}
set15 = {"b", "c", "d"}
print(set14.intersection(set15))   # {'b', 'c'}

• intersection_update() 返回集合的交集

set16 = {"a", "b", "c"}
set17 = {"b", "c", "d"}
set16.intersection_update(set17)
print(set16)  # {'b', 'c'}

• isdisjoint() 两个集合,如果没有相同元素返回 True，有至少一个相同元素返回 False。

set18 = {"a", "b", "c"}
set19 = {"1", "2", "3"}
print(set18.isdisjoint(set19))  # True

• issubset() 判断指定集合是否为该方法参数集合的子集

set20 = {"a", "b", "c"}
set21 = {"b", "c", "d"}
print(set20.issubset(set21))  # False

• issuperset() 判断该方法的参数集合是否为指定集合的子集

set22 = {"a", "b", "c"}
set23 = {"b", "c"}
print(set22.issuperset(set23))  # True

• symmetric_difference() 返回两个集合中不重复的元素集合。

set24 = {"a", "b", "c"}
set25 = {"b", "c", "d"}
print(set24.symmetric_difference(set25))  # {'d', 'a'}

• symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

set26 = {"a", "b", "c"}
set27 = {"b", "c", "d"}
set26.symmetric_difference_update(set27)
print(set26)  # {'d', 'a'}

• union() 返回两个集合的并集

set28 = {"a", "b", "c"}
set29 = {"b", "c", "d"}
print(set28.union(set29))  #{'a', 'b', 'd', 'c'}

字典

• 创建字典

dict = {}  #使用{}创建一个空字典
emptyDict2 = dict()   #使用内建函数 dict() 创建字典
dict2 = {'key1': 'value1', 'key2': 1, 'key3': 'value3'}  #使用{}创建一个有值的字典

• dict()可以直接将键值对儿转为字典

print(dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])

输出：
{'Runoob': 1, 'Google': 2, 'Taobao': 3}

• 字典访问

dict['a'] = "b"
dict[1] = 1
print(dict['a'])  # 输出键为 'one' 的值
# print(dict[2])  # 输出键为 2 的值 ,找不到，报错
print(dict2)  # 输出完整的字典

输出：
b
{'key1': 'value1', 'key2': 1, 'key3': 'value3'}

• del 删除字典的key

dict2 = {'key1': 'value1', 'key2': 1, 'key3': 'value3'}
del dict2['key1']
print(dict2)  #{'key2': 1, 'key3': 'value3'}

• del 删除字典

dict3 = {'key1': 'value1', 'key2': 1, 'key3': 'value3'}
del dict3
# print(dict3)  #已删除，打印报错

• clear 字典清空

dict4 = {'key1': 'value1', 'key2': 1, 'key3': 'value3'}
dict4.clear()
print(dict4)  #{}

• len 字典内键值对儿个数

dict5 = {'key1': 'value1', 'key2': 1, 'key3': 'value3'}
print(len(dict5))  #3

• str 字典转为字符串

dict6 = {'key1': 'value1', 'key2': 1, 'key3': 'value3'}
print(str(dict6))  #字符串：{'key1': 'value1', 'key2': 1, 'key3': 'value3'}

• copy 返回一个字典的浅复制

dict7 = {'key1': 'value1', 'key2': 1, 'key3': 'value3'}
dict8 = dict7.copy()
print(str(dict8))  #{'key1': 'value1', 'key2': 1, 'key3': 'value3'}

• fromkeys 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

keys = ('name', 'age', 'sex')
values = "value"
dict9 = dict.fromkeys(keys, values)
print(dict9)  #{'name': 'value', 'age': 'value', 'sex': 'value'}

• 字典遍历

dict2 = {'key1': 'value1', 'key2': 1, 'key3': 'value3'} 
print(dict2.keys())  # 输出所有键，是个List
print(dict2.values())  # 输出所有值，是个List

输出：
dict_keys(['key1', 'key2', 'key3'])
dict_values(['value1', 1, 'value3'])

• for、keys、values，字典遍历

dict10 = {'key1': 'value1', 'key2': 1, 'key3': 'value3'}
print(dict10.get("key1"))    #value1

dict11 = {'key1': 'value1', 'key2': 1, 'key3': 'value3'}
print("key1" in dict11)  #True

dict12 = {'key1': 'value1', 'key2': 1, 'key3': 'value3'}
for entry in dict12.items():
    print(entry)
    
for k, v in dict12.items():
    print(k, v)
    
for key in dict12.keys():
    print(key)

for value in dict12.values():
    print(value)

• setdefault 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

dict13 = {'key1': 'value1', 'key2': 1, 'key3': 'value3'}
dict13.setdefault("key4",44)
print(dict13.get("key4"))  #44

• update 把字典dict15的键/值对更新到dict14里，存在更新，不存在添加

dict14 = {'key1': 'value1', 'key2': 1, 'key3': 'value3'}
dict15 = {'key1': 'value1111', 'key2': 3, 'key4': 'value444'}
dict14.update(dict15)
print(dict14)  #{'key1': 'value1111', 'key2': 3, 'key3': 'value3', 'key4': 'value444'}

• pop 删除字典 key（键）所对应的值，返回被删除的值

dict16 = {'key1': 'value1', 'key2': 1, 'key3': 'value3'}
dict16.pop("key1")
print(dict16)  #{'key2': 1, 'key3': 'value3'}

• popitem 返回并删除字典中的最后一对键和值

dict17 = {'key1': 'value1', 'key2': 1, 'key3': 'value3'}
dict17.popitem()
print(dict17)  #{'key1': 'value1', 'key2': 1}

数据类型转化

• 隐式类型转换 - 自动完成
• 显式类型转换 - 需要使用类型函数来转换

隐式转换：

a = 1 # int
b = 1.2 # float
c = a + b # float

a = 1 # int
b = "1" # float
c = a + b # 运行报错，字符串和int不能隐式转换

显示转化，使用目标类型名函数：

print(int(1.2))
print(int("1"))
print(float(1))
print(float("1.3"))
print(str(1))
print(str(1.2))

显示转化汇总：

• int(x) 将x转换为一个整数
• float(x) 将x转换到一个浮点数
• complex(x) 创建一个复数
• str(x) 将x转为字符串
• repr(x) 将x转为表达式字符串
• eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
• tuple(s) 将序列 s 转换为一个元组
• list(s) 将序列 s 转换为一个列表
• set(s) 转换为可变集合
• dict(d) 创建一个字典。d 必须是一个 (key, value)元组序列
• frozenset(s) 转换为不可变集合
• chr(x) 将一个整数转换为一个字符
• ord(x) 将一个字符转换为它的整数值
• hex(x) 将一个整数转换为一个十六进制字符串
• oct(x) 将一个整数转换为一个八进制字符串

推导式

推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。

• 列表(list)推导式
• 字典(dict)推导式
• 集合(set)推导式
• 元组(tuple)推导式

列表(list)推导式

list = ['ZhangSan', 'LiSi', 'wei', 'wangwu', 's', 'a']
list2 = [name.upper() for name in list if len(name) > 3]
print(list2) # ['ZHANGSAN', 'LISI', 'WANGWU']

list3 = [i for i in range(20) if i%4 == 0]
print(list3) # [0, 4, 8, 12, 16]

字典(dict)推导式

list = ['key1', 'key222', 'key33333']
dict = {key: len(key) for key in list}
print(dict) # {'key1': 4, 'key222': 6, 'key33333': 8}

dict2 = {x: x ** 2 for x in (2, 4, 6)}
print(dict2) # {2: 4, 4: 16, 6: 36}

集合(set)推导式

set1 = {i ** 2 for i in (1, 2, 3)}
print(set1)  # {1, 4, 9}
a = {x for x in 'abracadabra' if x not in 'abc'}
print(a)  # {'r', 'd'}

元组(tuple)推导式

a = (x for x in range(1, 10))  # 返回的生成器对象，需要用tuple(a)转换成元组
print(tuple(a))  # (1, 2, 3, 4, 5, 6, 7, 8, 9)

运算符

• 算数运算符
• 比较运算符
• 赋值运算符
• 逻辑运算符
• 位运算符
• 成员运算符
• 身份运算符
• 运算符优先级

a = 2
b = 20
list = [1, 2, 3, 4, 5]
if (a in list):
    print("1 - 变量 a 在给定的列表中 list 中")
else:
    print("1 - 变量 a 不在给定的列表中 list 中")
if (b not in list):
    print("2 - 变量 b 不在给定的列表中 list 中")
else:
    print("2 - 变量 b 在给定的列表中 list 中")

a = 20
b = 20

if (a is b):
    print("1 - a 和 b 有相同的标识")
else:
    print("1 - a 和 b 没有相同的标识")

if (id(a) == id(b)):
    print("2 - a 和 b 有相同的标识")
else:
    print("2 - a 和 b 没有相同的标识")

数学函数

常用函数

函数	返回值 ( 描述 )
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y)	如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃，使用 (x>y)-(x<y) 替换。
exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)	返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,...)	返回给定参数的最小值，参数可以为序列。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	x**y 运算后的值。
round(x [,n])	返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。其实准确的说是保留值将保留到离上一位更近的一端。
sqrt(x)	返回数字x的平方根。

随机数函数

常用随机数函数：

函数	描述
choice(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange ([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random()	随机生成下一个实数，它在[0,1)范围内。
seed([x])	改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst)	将序列的所有元素随机排序
uniform(x, y)	随机生成下一个实数，它在[x,y]范围内。

三角函数

常用三角函数：

函数	描述
acos(x)	返回x的反余弦弧度值。
asin(x)	返回x的反正弦弧度值。
atan(x)	返回x的反正切弧度值。
atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值。
cos(x)	返回x的弧度的余弦值。
hypot(x, y)	返回欧几里德范数 sqrt(xx + yy)。
sin(x)	返回的x弧度的正弦值。
tan(x)	返回x弧度的正切值。
degrees(x)	将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x)	将角度转换为弧度

数学常量

常量	描述
pi	数学常量 pi（圆周率，一般以π来表示）
e	数学常量 e，e即自然常数（自然常数）。

end

关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符

a, b = 0, 1
while b < 1000:
    print(b, end=',')
    a, b = b, a + b
    
输出：
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

循环

• while else

while true内执行多次，else执行1次

count = 10
while count < 5:
    print(count, " 小于 5")
    count = count - 1
else:
    print(count, " 大于或等于 5")
    count = count - 1

• for else

只有for内循环一次都未执行时才走else

sites = ["a", "b", "c", "d"]
for site in sites:
    if site == "b":
        print("aaa!")
        break
    print("循环数据 " + site)
else:
    print("没有循环数据!")
print("完成循环!")

• range

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

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

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

for i in range(-10, -100, -30):
    print(i)

list = list(range(5))
print(list)

• pass

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

for letter in 'abcde':
    if letter == 'o':
        pass
        print('执行 pass 块')
    print('当前字母 :', letter)

同时遍历两个序列

questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
for q, a in zip(questions, answers):
    print('q = {0}?  a = {1}.'.format(q, a))
    
输出：
q = name?  a = lancelot.
q = quest?  a = the holy grail.
q = favorite color?  a = blue.

异常处理

• 如果没有异常：try...else...finally...
• 有异常：try...except...finally...

def this_fails():
    x = 1 / 0

try:
    this_fails()
except ZeroDivisionError as err:
    print('Handling run-time error:', err)
else:
    print("oveer")
finally:
    print('这句话，无论异常是否发生都会执行。')

• 抛出异常 raise

x = 10\
if x > 5:\
    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))

• 自定义异常

class MyError(Exception):
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return repr(self.value)

try:
    raise MyError(2 * 2)
except MyError as e:
    print('My exception occurred, value:', e.value)

• with

关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法

with open("myfile.txt") as f:
    for line in f:
        print(line, end="")

类

class MyClass:
    """一个简单的类实例"""
    i = 12345
    a = 1
    b = 2
    __c = 2  # 私有属性

    def __init__(self, a, b):  # 构造方法
        self.i = 222
        self.a = a
        self.b = b

    def f(self):  # 常规方法
        return self.a + self.b + self.__c
        
    def __foo(self):  # 私有方法 
        print('这是私有方法')

# 实例化类
x = MyClass(3,4)

# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())

• 继承

class MySubClass(MyClass):
    d = 4

    def __init__(self,a,b,d):
        MyClass.__init__(self,a,b)  # 调用父类构造方法
        self.d = d

    def f(self):  # 覆写父类方法
        return self.a * self.b *self.d

msc = MySubClass(2,2,3)
result = msc.f()
print(result)

• 多继承

# 类定义
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("Tim", 25, 80, 4, "Python")
test.speak()  # 方法名同，默认调用的是在括号中参数位置排前父类的方法

json

• dumps 对象转字符串
• loads 字符串转对象

import json
data = {
    'no': 1,
    'name': 'Runoob',
    'url': 'http://www.runoob.com'
}

json_str = json.dumps(data)
print("Python 原始数据：", repr(data))
print("JSON 对象：", json_str)

# 将 JSON 对象转换为 Python 字典
data2 = json.loads(json_str)
print("data2['name']: ", data2['name'])
print("data2['url']: ", data2['url'])

参考菜鸟教程：www.runoob.com/python3/pyt…