Python小栈

(1+32)*（16%7）/7= 0.8571428571428571
(1+32)16%7/7=2.857142857142857
注：如果按照计算优先级顺序是先算在取余

变量、运算符与数据类型

# 行注释
'''
多行注释
'''
""" 
多行注释
"""

运算符

#算术运算符
print(3//4)	#整除 0
print(2**3) #幂 8
#逻辑运算符
print(not(2>1)) #非 Flase
#位运算符
print(~4) #按位取反 -5
print(4^5) #按位异或 1
print(4<<2) #左移 16 >>右移

三元运算符

#可使用三元运算符，一条语句完成判断和赋值
x, y = 4, 5
small = x if x < y else y
print(small)  # 4

in、is

in	‘A’ in [‘A’, ‘B’, ‘C’] #存在
not in	不存在
i s	“hello” is “hello” #是
not is	不是

注意：is，is not 对比的是两个变量的内存地址，!=对比的是两个变量的类型

a = ["hello"]
b = ["hello"]
print(a is b, a == b)  # False True
print(a is not b, a != b)  # True False

运算符的优先级

1. 一元运算符优先于二元运算符
2. 先算数运算，后移位运算，最后位运算
3. 逻辑运算最后

变量和赋值

1.使用变量之前，需要对其先赋值。
2.变量名可以包括字母、数字、下划线、但变量名不能以数字开头。
3.Python变量名是大小写敏感的。

数据类型和转换

类型：int、float、bool
type(a) 查看数据类型
Python中万物皆对象
Python里面有很多用途广泛的包(package)，用什么你就引进(import)什么。包也是对象，也可以用上面提到
的dir(decimal)来看其属性和方法。
除了直接给变量赋值True和False，还可以用bool(X)来创建变量，其中X可以是
1.基本类型：整型、浮点型、布尔型
2.容器类型：字符、元组、列表、字典和集合

• bool作用在基本类型变量：X=0或0.0，bool(X)就是False，其余就是True。
• bool作用在容器类型变量：X是空的变量，bool(X)就是False，其余就是True。

获取类型信息

1.获取类型信息

• type(object）
• isinstance(object,classinfo)

print(type(1))	# <class 'int'>
print(isinstance(1, int))  # True

注：
1.type()不会认为子类是一种父类类型，不考虑继承关系。2.isinstance()会认为子类是一种父类类型，考虑继承关系。如果要判断两个类型是否相同推荐使用isinstance()。

类型转换

1.转换为整型int(x,base=10)
2.转换为字符串str(object=’’)
3.转换为浮点型float(x)

print()函数

语法：

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

关键字：

sep是实现分隔符、end 是输出结束时的字符、file 是定义流输出的文件，可以是标准的系统输出 sys.stdout ，也可以重定义为别的文件、flush 是立即把内容输出到流文件，不作缓存。

• 无参数时，每次输出都会换行，都用 end 设置的参数 & 结尾，并没有默认换行。

位运算

原码、反码、补码

二进制有三种不同的表示形式：原码、反码和补码，计算机内部使用补码来表示。

• 原码：就是其二进制表示（注意，有一位符号位）。
• 反码：正数的反码就是原码，负数的反码是符号位不变，其余位取反（对应正数按位取反）。
• 补码：正数的补码就是原码，负数的补码是反码+1。
• 符号位：最高位为符号位，0表示正数，1表示负数。在位运算中符号位也参与运算

利用位运算实现快速计算???

通过 << ， >> 快速计算2的倍数问题。

n << 1 -> 计算 n*2
n >> 1 -> 计算 n/2，负奇数的运算不可用
n << m -> 计算 n*(2^m)，即乘以 2 的 m 次方
n >> m -> 计算 n/(2^m)，即除以 2 的 m 次方
1 << n -> 2^n

条件语句

if语句

if expression:
 expr_true_suite

单个 if 语句中的 expression 条件表达式可以通过布尔操作符 and ， or 和 not 实现多重条件判断。

if-else语句

if expression:
 expr_true_suite
else
 expr_false_suite

if 语句支持嵌套。Python 使用缩进而不是大括号来标记代码块边界，因此要特别注意 else 的悬挂问题。

if-elif-else语句

if expression1:
 expr1_true_suite
elif expression2:
 expr2_true_suite
 .
 .
elif expressionN:
 exprN_true_suite
else:
 expr_false_suite

elif==else if

assert 关键字

assert 这个关键词我们称之为“断言”，当这个关键词后边的条件为 False 时，程序自动崩溃并抛出 AssertionError 的异常。
在进行单元测试时，可以用来在程序中置入检查点，只有条件为 True 才能让程序正常工作。

assert 3 > 7
# AssertionError

循环语句

while

while 布尔表达式:
	代码块

除了布尔表达式，还可以带运算符、非零整数，为0时，为假、str、list或任何序列，长度非零则视为真，否则为假。

while-else

while 布尔表达式:
	代码块
else:
	代码块

当 while 循环正常执行完的情况下，执行 else 输出，如果 while 循环中执行了跳出循环的语句，比如 break ，将不执行 else 代码块的内容。

for

for 迭代变量 in 可迭代对象:
	代码块

for循环是迭代循环，在Python中相当于一个通用的序列迭代器，可以遍历任何有序序列，如 str、list、tuple 等，也可以遍历任何可迭代对象，如 dict 。

for-else

for 迭代变量 in 可迭代对象:
代码块
else:
代码块

当 for 循环正常执行完的情况下，执行 else 输出，如果 for 循环中执行了跳出循环的语句，比如 break ，将不执行 else 代码块的内容，与 while - else 语句一样。

range()函数

range([start,] stop[, step=1])

• 这个BIF（Built-in functions）有三个参数，其中用中括号括起来的两个表示这两个参数是可选的。（可填可不填）
• step=1 表示第三个参数的默认值是1。
• range 这个BIF的作用是生成一个从 start 参数的值开始到 stop 参数的值结束的数字序列，step表示步长
• 该函数为左闭右开

enumerate()函数

enumerate(sequence, [start=0])

• sequence – 一个序列、迭代器或其他支持迭代对象。
• start – 下标起始位置。
• 返回 enumerate(枚举) 对象

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
lst = list(enumerate(seasons)) #默认从0开始
print(lst)
# [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
lst = list(enumerate(seasons, start=1)) # 下标从 1 开始
print(lst)
# [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

例：与for 循环结合

for i, language in enumerate(languages, 2):
 print(i, 'I love', language)
print('Done!')
'''
2 I love Python
3 I love R
4 I love Matlab
5 I love C++
Done!

break、continue、pass

• break 语句可以跳出当前所在层的循环。
• continue 终止本轮循环并开始下一轮循环。
• pass 是空语句，不做任何操作，只起到占位的作用，其作用是为了保持程序结构的完整性。

推导式

列表推导式

 [ expr for value in collection [if condition] ]

例：

a = [(i, j) for i in range(0, 3) if i < 1 for j in range(0, 3) if j > 1]
print(a)
# [(0, 2)]

元组推导式

( expr for value in collection [if condition] )

例：

a = (x for x in range(10))
print(a)
# <generator object <genexpr> at 0x0000025BE511CC48>
print(tuple(a))
# (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

字典推导式

{ key_expr: value_expr for value in collection [if condition] }

例：

b = {i: i % 2 == 0 for i in range(10) if i % 3 == 0}
print(b)
# {0: True, 3: False, 6: True, 9: False}

集合推导式

{ expr for value in collection [if condition] }

例：

c = {i for i in [1, 2, 3, 4, 5, 5, 6, 4, 3, 2, 1]}
print(c)
# {1, 2, 3, 4, 5, 6}

异常处理

Python标准异常总结

1. BaseException：所有异常的 基类
2. Exception：常规异常的 基类
3. StandardError：所有的内建标准异常的基类
4. ArithmeticError：所有数值计算异常的基类
5. FloatingPointError：浮点计算异常
6. OverflowError：数值运算超出最大限制
7. ZeroDivisionError：除数为零
8. AssertionError：断言语句（assert）失败
9. AttributeError：尝试访问未知的对象属性
10. EOFError：没有内建输入，到达EOF标记
11. EnvironmentError：操作系统异常的基类
12. IOError：输入/输出操作失败
13. OSError：操作系统产生的异常（例如打开一个不存在的文件）
14. WindowsError：系统调用失败
15. ImportError：导入模块失败的时候
16. KeyboardInterrupt：用户中断执行
17. LookupError：无效数据查询的基类
18. IndexError：索引超出序列的范围
19. KeyError：字典中查找一个不存在的关键字
20. MemoryError：内存溢出（可通过删除对象释放内存）
21. NameError：尝试访问一个不存在的变量
22. UnboundLocalError：访问未初始化的本地变量
23. ReferenceError：弱引用试图访问已经垃圾回收了的对象
24. RuntimeError：一般的运行时异常
25. NotImplementedError：尚未实现的方法
26. SyntaxError：语法错误导致的异常
27. IndentationError：缩进错误导致的异常
28. TabError：Tab和空格混用
29. SystemError：一般的解释器系统异常
30. TypeError：不同类型间的无效操作
31. ValueError：传入无效的参数
32. UnicodeError：Unicode相关的异常
33. UnicodeDecodeError：Unicode解码时的异常
34. UnicodeEncodeError：Unicode编码错误导致的异常
35. UnicodeTranslateError：Unicode转换错误导致的异常
    Python标准警告总结
36. Warning：警告的基类
37. DeprecationWarning：关于被弃用的特征的警告
38. FutureWarning：关于构造将来语义会有改变的警告
39. UserWarning：用户代码生成的警告
40. PendingDeprecationWarning：关于特性将会被废弃的警告
41. RuntimeWarning：可疑的运行时行为(runtime behavior)的警告
42. SyntaxWarning：可疑语法的警告
43. ImportWarning：用于在导入模块过程中触发的警告
44. UnicodeWarning：与Unicode相关的警告
45. BytesWarning：与字节或字节码相关的警告
    38
46. ResourceWarning：与资源使用相关的警告

try-except 语句

try:
	检测范围
except Exception[as reason]:
	出现异常后的处理代码

• 先执行try子句，若没有异常，忽略expect子句
• 发生异常，try余下部分忽略，执行匹配的except子句，若没有匹配的except子句，异常将传递给上层，最后执行try语句后的代码

dict1 = {'a': 1, 'b': 2, 'v': 22}
try:
 	x = dict1['y']
except LookupError:
 	print('查询错误')
except KeyError:
 	print('键错误')
else:
	print(x)
# 查询错误

try-except-else 语句尝试查询不在 dict 中的键值对，从而引发了异常。这一异常准确地说应属于 KeyError ，但由于 KeyError 是 LookupError 的子类，且将 LookupError 置于 KeyError 之前，因此程序优先执行该 except 代码块。所以，使用多个 except 代码块时，必须坚持对其规范排序，要从最具针对性的异常到最通用的异常。

try:
 	s = 1 + '1'
	int("abc")
 	f = open('test.txt')
	print(f.read())
	f.close()
except (OSError, TypeError, ValueError) as error:
	print('出错了！\n原因是：' + str(error))
# 出错了！
# 原因是：unsupported operand type(s) for +: 'int' and 'str'

一个 except 子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组。

try-except-finally语句

try:
	检测范围
except Exception[as reason]:
	出现异常后的处理代码
finally:
	无论如何都会被执行的代码

不管 try 子句里面有没有发生异常， finally 子句都会执行。

try-except-else

try:
	检测范围
except:
	出现异常后的处理代码
else:
	如果没有异常执行这块代码

如果在 try 子句执行时没有发生异常，Python将执行 else 语句后的语句。
else 语句的存在必须以 except 语句的存在为前提，在没有 except 语句的 try 语句中使用 else 语句，会引发
语法错误。

raise

Python 使用 raise 语句抛出一个指定的异常。

列表

简单数据类型

1. 整型 <class ‘int’>
2. 浮点型 <class ‘float’>
3. 布尔型 <class ‘bool’>
   容器数据类型
4. 列表 <class ‘list’>
5. 元组 <class ‘tuple’>
6. 字典 <class ‘dict’>
7. 集合 <class ‘set’>
8. 字符串 <class ‘str’>

定义：列表是有序集合，没有固定大小，能够保存任意数量任意类型的 Python 对象，语法为 [元素1, 元素2, …, 元素n] 。

创建列表

1、普通列表

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

2、用range()创建列表

x = list(range(10))
print(x, type(x))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>

3、用推导式创建列表

x = [0] * 5
print(x, type(x))
# [0, 0, 0, 0, 0] <class 'list'>
x = [0 for i in range(5)]
print(x, type(x))
# [0, 0, 0, 0, 0] <class 'list'>
x = [i for i in range(10)]
print(x, type(x))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>

4、创建一个 4×3的二维数组

x = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]]
print(x, type(x))
# [[1, 2, 3], [4, 5, 6], [7, 8, 9], [0, 0, 0]] <class 'list'>

• 由于list的元素可以是任何对象，因此列表中所保存的是对象的指针。即使保存一个简单的 [1,2,3] ，也有3个指针和3个整数对象。
• x = [a] * 4 操作中，只是创建4个指向list的引用，所以一旦 a 改变， x 中4个 a 也会随之改变。
  5、创建混合列表

mix = [1, 'lsgo', 3.14, [1, 2, 3]]
print(mix) # [1, 'lsgo', 3.14, [1, 2, 3]]

删除元素

• list.remove(obj) 移除列表中某个值的第一个匹配项
• list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
• del var1[, var2 ……] 删除单个或多个对象。

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.remove('Monday')
print(x) # ['Tuesday', 'Wednesday', 'Thursday', 'Friday']

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
y = x.pop()
print(y) # Friday

x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
del x[0:2]
print(x) # ['Wednesday', 'Thursday', 'Friday']

如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用 del 语句；如果你要在删除元素后还能继续使用它，就使用方法 pop() 。

获取元素

• 通过索引可获取单个列表元素（从0开始）
• 索引为-1返回最后一个列表元素、-2倒数第二个…

切片法

切片是Python序列的重要操作之一，除了适用于列表，还适用于元组、字符串、range对象。切片不仅可以截取列表中的任何部分返回一个新列表，还可以通过列表来增加、修改和删除列表中的部分元素。

list[start=0:stop=list.len:step=1]

• 当start=0时，可省略
• 当end为列表长度是可省略
• 当step=1时，可省略，还可以省略最后一个：
• 当step为负整数时，表示反向切片，这时start应在end右侧
• 区间为左闭右开
  例：复制列表中的所有元素（浅拷贝：拷贝了地址，数据会随着改变；深拷贝：拷贝一个新对象，数据不会随着改变）。

list1 = [123, 456, 789, 213]
list2 = list1
list3 = list1[:]
print(list2) # [123, 456, 789, 213]
print(list3) # [123, 456, 789, 213]
list1.sort()
print(list2) # [123, 213, 456, 789]	改变
print(list3) # [123, 456, 789, 213]	不变

list常用操作符

1. 等号操作符： ==
2. 连接操作符： +
3. 重复操作符：*
4. 成员关系操作符： in 、 not in

• [等号 （==）]，只有成员、成员位置都相同时才返回True。
• 和元组拼接一样， 列表拼接也有两种方式，用[加号 +]和[乘号 *]，前者首尾拼接，后者复制拼接。

list1 = [123, 456]
list2 = [456, 123]
list3 = [123, 456]
print(list1 == list2) # False
print(list1 == list3) # True
list4 = list1 + list2 # extend()
print(list4) # [123, 456, 456, 123]
list5 = list3 * 3
print(list5) # [123, 456, 123, 456, 123, 456]
print(123 in list3) # True

（ append , extend , insert ）可对列表增加元素，它们没有返回值，是直接修改了原数据对象。将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存，特别是当 list 较大时，尽量不要使用 “+” 来添加list。

list其他方法

方法	说明
list.count(obj)	返回某个元素在列表中出现的次数
list.index(x[, start[, end]])	返回列表中与某个值第一个匹配项的索引
list.reverse()	原地逆序
list.sort(key=None, reverse=False)	对原列表进行排序。(key 用来指定排序规则，reverse为Flase表示升序、 True表示降序默认)，无返回值
list.append(x)	将x就加到列表尾部
list.extend(L)	将列表L中的所有元素追加至列表尾部
list.insert(index,x)	在列表index位置插入x，该位置后所有元素后移，若index为整数且大于列表长度则在尾部追加，若为负数且小于列表长度的相反数则在头部插入元素
list.remove(x)	从列表中删除第一个值为x的元素，且之后所有有元素前移，若不存在则抛出异常
list.pop([index=-1])	删除并返回列表中下标为index的元素，其后元素索引-1；若index不在区间则抛出异常
list.clear()删除列表所有元素，保留列表对象
list.copy()	返回列表的浅复制
copy.deepcopy(obj)	返回深复制对象

浅复制：指生成一个新的列表，并把原列表中所有元素的引用都复制到新列表中。
深复制：指原列表中的元素进行递归，把所有的值都复制到新列表中，对嵌套的子列表不再是复制引用

元组

• Python 的元组与列表类似，不同之处在于tuple被创建后就不能对其进行修改

定义：元组使用小括号，列表使用方括号

• 可以用小括号()，也可以什么都不用
• 只包含一个元素时，需要在元素后面加逗号，否则会被当做运算符使用

temp = (1,)
print(type(temp)) # <class 'tuple'>
print(8 * (8)) # 64
print(8 * (8,)) # (8, 8, 8, 8, 8, 8, 8, 8)
#创建二维元组
nested = (1, 10.31, 'python'), ('data', 11)
print(nested)
# ((1, 10.31, 'python'), ('data', 11))

• 元组中可以用整数来对它进行索引 (indexing) 和切片 (slicing)
• 元组有不可更改 (immutable) 的性质，因此不能直接给元组的元素赋值，但是只要元组中的元素可更改 (list)，则可以直接更改其元素

元组相关操作符

1. 比较操作符
2. 逻辑操作符
3. 连接操作符 +
4. 重复操作符 *
5. 成员关系操作符 in 、 not in
   元组拼接 (concatenate) 有两种方式，用「加号 +」和「乘号 *」，前者首尾拼接，后者复制拼接。

内置方法

元组大小和内容都不可更改，因此只有 count 和 index 两种方法。

解压元组

解压一维元组：有几个元素定义几个变量

t = (1, 10.31, 'python')
(a, b, c) = t
print(a, b, c)
# 1 10.31 python

解压二维元组（按照元组里的元组结构来定义变量）

t = (1, 10.31, ('OK', 'python'))
(a, b, (c, d)) = t
print(a, b, c, d)
# 1 10.31 OK python

用通配符「*」，英文叫 wildcard，在计算机语言中代表一个或多个元素

t = 1, 2, 3, 4, 5
a, b, *rest, c = t
print(a, b, c) # 1 2 5
print(rest) # [3, 4]

用通配符「*」加上下划线「_」

a, b, *_ = t
print(a, b) # 1 2

字符串

• Python 中字符串被定义为引号之间的字符集合。
• Python 支持使用成对的 单引号 或 双引号。

转义字符

如果字符串中需要出现单引号或双引号，可以使用转义符号 \ 对字符串中的符号进行转义。

转义字符	描述
\ \	反斜杠
\ ’	单引号
"	双引号
\n	换行
\t	横向制表符（Tab）
\r	回车

原始字符串只需要在字符串前边加一个英文字母 r 即可。

print(r'C:\Program Files\Intel\Wifi\Help')
# C:\Program Files\Intel\Wifi\Help

python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。

制服穿的切片和连接

类似与元组，字符串具有不可修改性

字符串常用内置方法

方法	描述
capitalize()	将字符串的第一个字符转换为大写
lower()	转换字符串中所有大写字符为小写
upper()	转换字符串中的小写字母为大写
swapcase()	将字符串中大写转换为小写，小写转换为大写
count(str, beg= 0,end=len(string))	返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数。
endswith(suffix, beg=0, end=len(string))	检查字符串是否以指定子字符串 suffix 结束，如果是，返回True,否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。
startswith(substr, beg=0,end=len(string))	检查字符串是否以指定子字符串 substr 开头，如果是，返回True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。
find(str, beg=0, end=len(string))	检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含，返回开始的索引值，否则返回 -1。
rfind(str, beg=0,end=len(string))	类似于 find() 函数，不过是从右边开始查找。
isnumeric()	如果字符串中只包含数字字符，则返回 True，否则返回 False。
ljust(width[, fillchar])	返回一个原字符串左对齐，并使用 fillchar （默认空格）填充至长度 width 的新字符串。
rjust(width[, fillchar])	返回一个原字符串右对齐，并使用 fillchar （默认空格）填充至长度 width 的新字符串。
lstrip([chars])	截掉字符串左边的空格或指定字符。
rstrip([chars])	在字符串上执行 lstrip() 和 rstrip()
replace(old, new [, max])	把 将字符串中的 old 替换成 new ，如果 max 指定，则替换不超过 max 次。
split(str="", [num])	不带参数默认是以空格为分隔符切片字符串，如果 num 参数有设置，则仅分隔 num 个子字符串，返回切片后的子字符串拼接的列表。

字符串格式化

1、format 格式化函数

str = "{0} Love {1}".format('I', 'Lsgogroup') # 位置参数
print(str) # I Love Lsgogroup
str = "{a} Love {b}".format(a='I', b='Lsgogroup') # 关键字参数
print(str) # I Love Lsgogroup
str = "{0} Love {b}".format('I', b='Lsgogroup') # 位置参数要在关键字参数之前
print(str) # I Love Lsgogroup
str = '{0:.2f}{1}'.format(27.658, 'GB') # 保留小数点后两位
print(str) # 27.66GB

2、字符串格式化描述

符号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串，用str()方法处理对象
%d	格式化整数
%o	格式化无符号八进制数
%f	格式化浮点数字，可指定小数点后的精度

print("我叫 %s 今年 %d 岁!" % ('小明', 10)) # 我叫 小明 今年 10 岁!

注意""%之间不要加逗号

可变类型和不可变类型

• 序列是以连续的整数为索引，与此不同的是，字典以"关键字"为索引，关键字可以是任意不可变类型，通常用字符串或数值
• 字典是 Python 唯一的一个 映射类型，字符串、元组、列表属于序列类型
  快速判断数据类型
  1、用 id(X) 函数，对 X 进行某种操作，比较操作前后的 id ，如果不一样，则 X 不可变，如果一样，则X 可变
  2、用 hash(X) ，只要不报错，证明 X 可被哈希，即不可变，反过来不可被哈希，即可变。
  不可变类型：数值、字符和元组
  可变类型： 列表、集合、字典

字典

定义：字典 是无序的 键:值（ key:value ）对集合，键必须是互不相同的（在同一个字典之内）。

• dict 内部存放的顺序和 key 放入的顺序是没有关系的。
• dict 查找和插入的速度极快，不会随着 key 的增加而增加，但是需要占用大量的内存。

{元素1, 元素2, ..., 元素n}

其中每一个元素是一个「键值对」-- 键:值 ( key:value )
创建

brand = ['李宁', '耐克', '阿迪达斯']
slogan = ['一切皆有可能', 'Just do it', 'Impossible is nothing']
print('耐克的口号是:', slogan[brand.index('耐克')])
# 耐克的口号是: Just do it
dic = {'李宁': '一切皆有可能', '耐克': 'Just do it', '阿迪达斯': 'Impossible is nothing'}
print('耐克的口号是:', dic['耐克'])
# 耐克的口号是: Just do it

dic = dict()
dic['a'] = 1
dic['b'] = 2
dic['c'] = 3
print(dic)
# {'a': 1, 'b': 2, 'c': 3}
#这种情况下，键只能为字符串类型，并且创建的时候字符串不能加引号，加上就会直接报语法错误。
dic = dict(name='Tom', age=10)
print(dic) # {'name': 'Tom', 'age': 10}
print(type(dic)) # <class 'dict'>

内置方法

方法	描述
dict.fromkeys(seq[, value])	用于创建一个新字典，以序列 seq 中元素做字典的键， value 为字典所有键对应的初始值
dict.keys()	返回一个可迭代对象，可以使用 list() 来转换为列表，列表为字典中的所有键
dict.values()	返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有值
dict.items()	以列表返回可遍历的 (键, 值) 元组数组
dict.get(key, default=None)	返回指定键的值，如果值不在字典中返回默认值。
dict.pop(key[,default])	删除字典给定键 key 所对应的值，返回值为被删除的值。 key 值必须给出。若 key不存在，则返回 default 值
del dict[key]	删除字典给定键 key 所对应的值
dict.popitem()	随机返回并删除字典中的一对键和值，如果字典已经为空，却调用了此方法，就报出KeyError异常
dict.clear()	用于删除字典内所有元素
dict.update(dict2)	把字典参数 dict2 的 key:value 对 更新到字典 dict 里

集合

python 中 set 与 dict 类似，也是一组 key 的集合，但不存储 value 。由于 key 不能重复，所以，在 set 中，没有重复的 key（key 为不可变类型，即可哈希的值）

创建

1.先创建对象再加入元素。在创建空集合的时候只能使用 s = set() ，因为 s = {} 创建的是空字典。

basket = set()
basket.add('apple')
basket.add('banana')
print(basket) # {'banana', 'apple'}

2.直接把一堆元素用花括号括起来 {元素1, 元素2, …, 元素n} 。 重复元素在 set 中会被自动被过滤。

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket) # {'banana', 'apple', 'pear', 'orange'}

3.使用 set(value) 工厂函数，把列表或元组转换成集合。

a = set('abracadabra')
print(a)
# {'r', 'b', 'd', 'c', 'a'}

运用：列表去重

lst = [0, 1, 2, 3, 4, 5, 5, 3, 1]
temp = []
for item in lst:
 if item not in temp:
 temp.append(item)
print(temp) # [0, 1, 2, 3, 4, 5]
a = set(lst)
print(list(a)) # [0, 1, 2, 3, 4, 5]

集合特点：无序、唯一
由于 set 存储的是无序集合，所以我们不可以为集合创建索引或执行切片(slice)操作，也没有键(keys)可用来获取集合中元素的值，但是可以判断一个元素是否在集合中。

访问集合元素

• 可以使用 len(Obj) 內建函数得到集合的大小。
• 以使用 for 把集合中的数据一个个读取出来。
• 可以通过 in 或 not in 判断一个元素是否在集合中已经存在。

集合内置方法

方法	描述
set.add(elmnt)	用于给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作
set.update(set)	用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略
set.remove(item)	用于移除集合中的指定元素。如果元素不存在，则会发生错误
set.discard(value)	用于移除指定的集合元素。 remove() 方法在移除一个不存在的元素时会发生错误，而discard() 方法不会
set.pop()	用于随机移除并返回一个元素

由于 set 是无序和无重复元素的集合，所以两个或多个 set 可以做数学意义上的集合操作。
1.返回两个集合的交集：

• set.intersection(set1, set2 …)
• set1 & set2
• set.intersection_update(set1, set2 …)
  1.返回两个集合的并集：
• set.union(set1, set2…)
• set1 | set2
  返回两个集合的差集：
• set.difference(set)
• set1 - set2
  3.集合的差集，直接在原来的集合中移除元素，没有返回值。
• set.difference_update(set)

1. set.symmetric_difference(set) 返回集合的异或。
2. set1 ^ set2 返回集合的异或。
3. set.symmetric_difference_update(set) 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
4. set.issubset(set) 判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。
5. set1 <= set2 判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。
6. set.issuperset(set) 用于判断集合是不是包含其他集合，如果是则返回 True，否则返回 False。
7. set1 >= set2 判断集合是不是包含其他集合，如果是则返回 True，否则返回 False。
8. set.isdisjoint(set) 用于判断两个集合是不是不相交，如果是返回 True，否则返回 False。

不可变的集合

Python 提供了不能改变元素的集合的实现版本，即不能增加或删除元素，类型名叫 frozenset 。需要注意的是 frozenset 仍然可以进行集合操作，只是不能用带有 update 的方法。
1、frozenset([iterable]) 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

序列

针对序列的内置函数

函数名	描述
list(sub)	把一个可迭代对象转换为列表
tuple(sub)	把一个可迭代对象转换为元组
str(obj)	把obj对象转换为字符串
len(s)	返回对象（字符、列表、元组等）长度或元素个数
max(sub)	返回序列或者参数集合中的最大值
min(sub)	返回序列或参数集合中的最小值
sum(iterable[, start=0])	返回序列 iterable 与可选参数 start 的总和
sorted(iterable, key=None, reverse=False)	返回对所有可迭代的对象进行排序操作
reversed(seq)	函数返回一个反转的迭代器

• enumerate(sequence, [start=0])
  用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
a = list(enumerate(seasons))
print(a)
# [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
b = list(enumerate(seasons, 1))
print(b)
# [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
for i, element in a:
 print('{0},{1}'.format(i, element))

• zip(iter1 [,iter2 […]])
  a. 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
  b. 我们可以使用 list() 转换来输出列表。
  c. 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]
zipped = zip(a, b)
print(zipped) # <zip object at 0x000000C5D89EDD88>
print(list(zipped)) # [(1, 4), (2, 5), (3, 6)]
zipped = zip(a, c)
print(list(zipped)) # [(1, 4), (2, 5), (3, 6)]
a1, a2 = zip(*zip(a, b))
print(list(a1)) # [1, 2, 3]
print(list(a2)) # [4, 5, 6]

函数与Lambda表达式

函数

1. 函数以 def 关键词开头，后接函数名和圆括号()。
2. 函数执行的代码以冒号起始，并且缩进。
3. return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None 。

def functionname(parameters):
 	"函数_文档字符串"
	 function_suite
	 return [expression]

函数参数

Python 的函数具有非常灵活多样的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。从简到繁的参数形态。
1、位置参数
2、默认参数

def functionname(arg1, arg2=v):
 	"函数_文档字符串"
 	function_suite
 	return [expression]

1. arg2 = v ：默认参数 = 默认值，调用函数时，默认参数的值如果没有传入，则被认为是默认值。
2. 默认参数一定要放在位置参数后面，不然程序会报错。
3. Python 允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
   3、可变参数
   可变参数就是传入的参数个数是可变的，可以是 0, 1, 2 到任意个，是不定长的参数。

def functionname(arg1, arg2=v, *args):
 	"函数_文档字符串"
 	function_suite
 	return [expression]

4. *args - 可变参数，可以是从零个到任意个，自动组装成元组。
5. 加了星号（*）的变量名会存放所有未命名的变量参数。

def printinfo(arg1, *args):
 print(arg1)
 for var in args:
 	print(var)
printinfo(10) # 10
printinfo(70, 60, 50)
# 70
# 60
# 50

4、关键字参数

def functionname(arg1, arg2=v, *args, **kw):
 	"函数_文档字符串"
 	function_suite
 	return [expression]

**kw - 关键字参数，可以是从零个到任意个，自动组装成字典。

def printinfo(arg1, *args, **kwargs):
 print(arg1)
 print(args)
 print(kwargs)
printinfo(70, 60, 50)
# 70
# (60, 50)
# {}
printinfo(70, 60, 50, a=1, b=2)
# 70
# (60, 50)
# {'a': 1, 'b': 2}

5、命名关键字参数

def functionname(arg1, arg2=v, *args, *, nkw, **kw):
 	"函数_文档字符串"
 	function_suite
	return [expression]

1. *, nkw - 命名关键字参数，用户想要输入的关键字参数，定义方式是在nkw 前面加个分隔符 *。
2. 如果要限制关键字参数的名字，就可以用「命名关键字参数」
3. 使用命名关键字参数时，要特别注意不能缺少参数名。

def printinfo(arg1, *, nkw, **kwargs):
 print(arg1)
 print(nkw)
 print(kwargs)
printinfo(70, nkw=10, a=1, b=2)
# 70
# 10
# {'a': 1, 'b': 2}
printinfo(70, 10, a=1, b=2)
# TypeError: printinfo() takes 1 positional argument but 2 were given

6、组合参数
在 Python 中定义函数，可以用位置参数、默认参数、可变参数、命名关键字参数和关键字参数，这 5 种参数中的 4 个都可以一起使用，但是注意，参数定义的顺序必须是：

1. 位置参数、默认参数、可变参数和关键字参数。
2. 位置参数、默认参数、命名关键字参数和关键字参数。
   要注意定义可变参数和关键字参数的语法：
3. *args 是可变参数， args 接收的是一个 tuple
4. *kw 是关键字参数， kw 接收的是一个 dict
   命名关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。定义命名关键字参数不要忘了写分隔符 ，否则定义的是位置参数。

变量作用域

1、定义在函数内部的变量拥有局部作用域，该变量称为局部变量。
2、定义在函数外部的变量拥有全局作用域，该变量称为全局变量。
3、局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。

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

num = 1
def fun1():
 global num # 需要使用 global 关键字声明
 print(num) # 1
 num = 123
 print(num) # 123
fun1()
print(num) # 123

内嵌函数

闭包

1. 是函数式编程的一个重要的语法结构，是一种特殊的内嵌函数。
2. 如果在一个内部函数里对外层非全局作用域的变量进行引用，那么内部函数就被认为是闭包。
3. 通过闭包可以访问外层非全局作用域的变量，这个作用域称为 闭包作用域。

def funX(x):
 	def funY(y):
 		return x * y
 	return funY#闭包的返回值通常是函数。

如果要修改闭包作用域中的变量则需要 nonlocal 关键字。

递归

一个函数在内部调用自身本身，这个函数就是递归函数。
例：斐波那契数列 f(n)=f(n-1)+f(n-2), f(0)=0 f(1)=1

def recur_fibo(n):
 	if n <= 1:
 		return n
 	return recur_fibo(n - 1) + recur_fibo(n - 2)

设置递归的层数，Python默认递归层数为 100

import sys
sys.setrecursionlimit(1000)

Lambda表达式

Python中两类函数：

1. 用def定义的正规函数
2. 用lambda定义的匿名函数

lambda argumet_list:expression

• expression 中没有return语句，表达式本身结果就是返回值
• 匿名函数有自己的命名空间，且不能访问自己参数列表之外或全局命名空间的参数

a=lambda x:x+3
print(a)
print([a(x) for x in range(5)])

#<function <lambda> at 0x00000000020A1E18>
#[3, 4, 5, 6, 7]

类与对象

对象是类的实例。换句话说，类主要定义对象的结构，然后我们以类为模板创建对象。类不但包含方法定义，而且还包含所有实例共享的数据。

1. 封装：信息隐蔽技术
   使用关键字 class 定义 Python 类，关键字后面紧跟类的名称、分号和类的实现。
2. 继承：子类自动共享父类之间数据和方法的机制
3. 多态：不同对象对同一方法响应不同的行动

self

Python 的 self 相当于 C++ 的 this 指针

Python的魔法方法

• init(self[, param1, param2…])
  该方法在类实例化时会自动调用。类似与构造方法

def __init__(self, name):
 self.name = name

公有和私有

在 Python 中定义私有变量只需要在变量名或函数名前加上“__”两个下划线，那么这个函数或变量就会为私有的了。

类、类对象和实例对象

类对象：创建一个类，其实也是一个对象也在内存开辟了一块空间，称为类对象，类对象只有一个。
实例对象：就是通过实例化类创建的对象，称为实例对象，实例对象可以有多个。

魔法方法

1. init(self[, …])
   构造器，当一个实例被创建的时候调用的初始化方法
2. new 方法
   主要是当你继承一些不可变的 class 时（比如 int, str, tuple ）， 提供给你一个自定义这些类的实例化过程的途径。
3. del(self)
   析构器，当一个对象将要被系统回收之时调用的方法
4. str(self)

• 当你打印一个对象的时候，触发 str
• 当你使用 %s 格式化的时候，触发 str
• str 强转数据类型的时候，触发 str

5. repr(self)

• repr 是 str 的备胎
• 有 str 的时候执行 str ,没有实现 str 的时候，执行 repr
• repr(obj) 内置函数对应的结果是 repr 的返回值
• 当你使用 %r 格式化的时候 触发 repr

算术运算符

类型工厂函数，指的是不通过类而是通过函数来创建对象

方法	描述
add(self, other)	定义加法的行为： +
sub(self, other)	定义减法的行为： -
mul(self, other)	定义乘法的行为： *
truediv(self, other)	定义真除法的行为： /
floordiv(self, other)	定义整数除法的行为： //
mod(self, other)	定义取模算法的行为： %
divmod(self, other)	定义当被 divmod() 调用时的行为
divmod(a, b)	把除数和余数运算结果结合起来，返回一个包含商和余数的元组 (a // b, a % b)
pow(self, other[, module])	定义当被 power() 调用或 ** 运算时的行为
lshift(self, other)	定义按位左移位的行为： <<
rshift(self, other)	定义按位右移位的行为： >>
and(self, other)	定义按位与操作的行为： &
xor(self, other)	定义按位异或操作的行为： ^
or(self, other)	定义按位或操作的行为：

反运算运算符

方法	描述
radd(self, other)	定义加法的行为： +
rsub(self, other)	定义减法的行为： -
rmul(self, other)	定义乘法的行为： *
rtruediv(self, other)	定义真除法的行为： /
rfloordiv(self, other)	定义整数除法的行为： //
rmod(self, other)	定义取模算法的行为： %
rdivmod(self, other)	定义当被 divmod() 调用时的行为
rpow(self, other[, module])	定义当被 power() 调用或 ** 运算时的行为
rlshift(self, other)	定义按位左移位的行为： <<
rrshift(self, other)	定义按位右移位的行为： >>
rand(self, other)	定义按位与操作的行为： &
rxor(self, other)	定义按位异或操作的行为： ^
ror(self, other)	定义按位或操作的行为：

增量赋值运算符

一元运算符

属性访问

getattr ， getattribute ， setattr 和 delattr
getattr(self, name) : 定义当用户试图获取一个不存在的属性时的行为。
getattribute(self, name) ：定义当该类的属性被访问时的行为（先调用该方法，查看是否存在该属性，若不存
在，接着去调用 getattr ）。
setattr(self, name, value) ：定义当一个属性被设置时的行为。
delattr(self, name) ：定义当一个属性被删除时的行为。

迭代器

1. 迭代是 Python 最强大的功能之一，是访问集合元素的一种方式。
2. 迭代器是一个可以记住遍历的位置的对象。
3. 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。
4. 迭代器只能往前不会后退。
5. 字符串，列表或元组对象都可用于创建迭代器。

迭代器有两个基本的方法： iter() 和 next() 。

1. iter(object) 函数用来生成迭代器。
2. next(iterator[, default]) 返回迭代器的下一个项目。
3. iterator – 可迭代对象
4. default – 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发
   StopIteration 异常。

模块

什么是模块：

1. 容器 -> 数据的封装
2. 函数 -> 语句的封装
3. 类 -> 方法和属性的封装
4. 模块 -> 程序文件

导入模块

 #第一种：import 模块名
import TemperatureConversion
#第二种：from 模块名 import 函数名
from TemperatureConversion import c2f, f2c
from TemperatureConversion import *
 第三种：import 模块名 as 新名字
 import TemperatureConversion as tc