1 基本数据类型
Python有五个标准的数据类型：
- Numbers（数字）
- String（字符串）
- List（列表）
- Tuple（元组）
- Dictionary（字典）
1.1 数字
数字数据类型用于存储数值，是不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。
Python支持四种不同的数字类型：
- int（有符号整型）
- long（长整型[也可以代表八进制和十六进制]）
- float（浮点型）
- complex（复数）
- bool（True和False，1和0）
当你指定一个值时，Number对象就会被创建：
#!/usr/bin/env python
# -*- coding:UTF-8 -*- number_a = 18 #整数 int
number_b = 3.1 #浮点 float
number_c = True #布尔 bool
number_d = 7+3j #复数 complex
print(type(number_a),"\n", type(number_b), "\n",type(number_c), "\n",type(number_d))
输出结果：
<class 'int'>
<class 'float'>
<class 'bool'>
<class 'complex'>
- 长整型也可以使用小写"L"，但是还是建议您使用大写"L"，避免与数字"1"混淆。Python使用"L"来显示长整型。
- Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型
数值运算
#!/usr/bin/env python
# -*- coding:UTF-8 -*- #数值运算
print (13+17) #加法
print (888-666) #减法
print (37 * 47) #乘法
print (3/4) #除法，得到一个浮点数
print (3//4) #整除，得到一个整数
print (22%3) #取余
print (3**2) #乘方
输出结果：
30
222
1739
0.75
0
1
9
注意：
- Python可以同时为多个变量赋值，如x, y = 1, 2。
- 数字运算的优先级是先乘除后加减，可以通过()来改变运算顺序。例如 print ((2+3)*3)。
- 数值的除法（/）总是返回一个浮点数，要获取整数使用//操作符。
- 在混合计算时，Python会把整型转换成为浮点数。
1.2 字符串
字符串常用功能：
- 移除空白
- 分割
- 长度
- 索引
- 切片
capitalize(self)
首字母变大写
>>> "hello world".capitalize()
'Hello world'
center(self, width, fillchar=None)
内容居中
width：总长度
fillchar：空白处填充内容，默认无
>>> "hello world".center(20,"*")
'****hello world*****'
count(self, sub, start=None, end=None)
子序列的个数
>>> "hello world".count("l")
3
startswith(self, prefix, start=None, end=None)
是否以XXX起始
>>> "hello world".startswith("h")
True
endswith(self, suffix, start=None, end=None)
判断字符串是否以XXX字符结束
>>> "hello world".endswith("d")
True
expandtabs(self, tabsize=None)
将tab转换成空格，默认一个tab转换成8个空格
>>> "hello\tworld".expandtabs()
'hello world'
find(self, sub, start=None, end=None)
寻找子序列的位置，如果没找到，返回 -1
>>> "hello world".find("o")
4
format(*args, **kwargs)
字符串格式化，动态参数
>>> "{} {}".format("James","")
'James 24'
>>> "{1} {0} {1}".format("James","")
'24 James 24'
index(self, sub, start=None, end=None)
子序列位置，如果没找到，报错
>>> "hello world".index("w")
6
isalnum(self)
是否是字母和数字
>>> "hello3".isalnum()
True
>>> "hello world".isalnum()
False
>>> "".isalnum()
True
>>> "hello".isalnum()
True
isalpha(self)
是否是字母
>>> "hello".isalnum()
True
>>> "".isalnum()
True
isdigit(self)
是否是数字
>>> "".isdigit()
True
>>> "hello".isdigit()
False
>>> "hello123".isdigit()
False
islower(self)
是否小写
>>> "hello".islower()
True
>>> "Hello".islower()
False
isupper(self)
是否大写
>>> "hello".isupper()
False
>>> "Hello".isupper()
False
>>> "HELLO".isupper()
True
lower(self)
变小写
>>> 'HELLO'.lower()
'hello'
upper(self)
变大写
>>> "hello".upper()
'HELLO'
swapcase(self)
大写变小写，小写变大写
>>> "Hello World".swapcase()
'hELLO wORLD'
ljust(self, width, fillchar=None)
内容左对齐，右侧填充
>>> "hello world".ljust(20,"*")
'hello world*********'
rjust(self, width, fillchar=None)
内容右对齐，左侧填充
>>> "hello world".rjust(20,"*")
'*********hello world'
strip(self, chars=None)
移除两端空白
>>> " hello world ".strip()
'hello world'
lstrip(self, chars=None)
移除左侧空白
>>> " hello world ".lstrip()
'hello world '
rstrip(self, chars=None)
移除右侧空白
>>> " hello world ".rstrip()
' hello world'
replace(self, old, new, count=None)
替换
>>> "hello world".replace("o","*")
'hell* w*rld'
1.3 列表
List（列表）是Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（所谓嵌套）。
列表用[ ]标识。是python最通用的复合数据类型。
创建列表：
name_list = ['James', 'Kobe', 'Yao']
或者
name_list ＝ list(['James', 'Koe', 'Yao'])
列表中的值的分割也可以用到变量[头下标:尾下标]，就可以截取相应的列表，从左到右索引默认0开始的，从右到左索引默认-1开始，下标可以为空表示取到头或尾。
加号（+）是列表连接运算符，星号（*）是重复操作。
如下实例：
#!/usr/bin/env python
# -*- coding:UTF-8 -*- list = [ 'James', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john'] print(list) # 输出完整列表
print(list[0]) # 输出列表的第一个元素
print(list[1:3]) # 输出第二个至第三个的元素
print(list[2:]) # 输出从第三个开始至列表末尾的所有元素
print(tinylist * 2) # 输出列表两次
print(list + tinylist) # 打印组合的列表
输出结果：
['James', 786, 2.23, 'john', 70.2]
James
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['James', 786, 2.23, 'john', 70.2, 123, 'john']
append(self, p_object)
>>> name = ["James","Kobe","Yao"]
>>> name.append("Rose")
>>> print(name)
['James', 'Kobe', 'Yao', 'Rose']
count(self, value)
>>> name = ["James","Kobe","Yao","James"]
>>> name.count("James")
2
extend(self, iterable)
>>> name1 = ["Kobe","James","Yao"]
>>> name2 = ["Ronaldo","Henry"]
>>> name1.extend(name2)
>>> print(name1)
['Kobe', 'James', 'Yao', 'Ronaldo', 'Henry']
index(self, value, start=None, stop=None)
>>> name = ["James","Kobe","Yao","James"]
>>> name.index("Yao")
2
insert(self, index, p_object)
>>> name = ["James","Kobe","Yao","James"]
>>> name.insert(2,"Henry")
>>> print(name)
['James', 'Kobe', 'Henry', 'Yao', 'James']
pop(self, index=None)
>>> name = ["James","Kobe","Yao","James"]
>>> name.pop()
'James'
>>> print(name)
['James', 'Kobe', 'Yao']
remove(self, value)
>>> name = ["James","Kobe","Yao","James"]
>>> name.remove("James")
>>> print(name)
['Kobe', 'Yao', 'James']
reverse(self)
>>> name = ["James","Kobe","Yao"]
>>> name.reverse()
>>> print(name)
['Yao', 'Kobe', 'James']
sort(self, cmp=None, key=None, reverse=False)
>>> name = ["Ronaldo","Kobe","James","Yao",""]
>>> name.sort()
>>> print(name)
['', 'James', 'Kobe', 'Ronaldo', 'Yao']
1.4 元组
元组是另一个数据类型，类似于List（列表）。
元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。
创建元祖：
ages = (11,22,33,44,55)
或者
ages = tuple((11,22,33,44,55))
基本操作：
- 索引
- 切片
- 循环
- 长度
- 包含
如下实例：
#!/usr/bin/env python
# -*- coding:UTF-8 -*- tuple = ( 'James', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john') print(tuple) # 输出完整元组
print(tuple[0]) # 输出元组的第一个元素
print(tuple[1:3]) # 输出第二个至第三个的元素
print(tuple[2:]) # 输出从第三个开始至列表末尾的所有元素
print(tinytuple * 2) # 输出元组两次
print(tuple + tinytuple) # 打印组合的元组
输出结果：
('James', 786, 2.23, 'john', 70.2)
James
(786, 2.23)
(2.23, 'john', 70.2)
(123, 'john', 123, 'john')
('James', 786, 2.23, 'john', 70.2, 123, 'john')
count(self, value)
>>> name = ("James","Kobe","James","Yao","James")
>>> name.count("James")
3
index(self, value, start=None, stop=None)
>>> name = ("James","Kobe","James","Yao","James")
>>> name.index("James")
0
>>> name.index("Yao")
3
1.5 字典
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典用"{ }"标识。字典由索引(key)和它对应的值value组成。
创建字典：
person = {"name":"James","age":24}
或者：
person = dict({"name":"James","age":24})
常用操作：
- 索引
- 新增
- 删除
- 键、值、键值对
- 循环
- 长度
如下实例：
#!/usr/bin/env python
# -*- coding:UTF-8 -*- dict = {}
dict['one'] = "This is one"
dict[2] = "This is two" tinydict = {'name': 'john','code':6734, 'dept': 'sales'} print(dict['one']) # 输出键为'one' 的值
print(dict[2]) # 输出键为 2 的值
print(tinydict) # 输出完整的字典
print(tinydict.keys()) # 输出所有键
print(tinydict.values()) # 输出所有值
输出结果：
This is one
This is two
{'code': 6734, 'name': 'john', 'dept': 'sales'}
dict_keys(['code', 'name', 'dept'])
dict_values([6734, 'john', 'sales'])
clear(self)
清除内容
>>> person = {"name":"James","age":24}
>>> person.clear()
>>> print(person)
{}
copy(self)
浅拷贝
>>> person1 = {"name":"James","age":24}
>>> person2 = person1.copy()
>>> print(person2)
{'name': 'James', 'age': 24}
>>> id(person1)
3082800364
>>> id(person2)
3082798892
get(self, k, d=None)
根据key获取值，d是默认值
>>> person = {"name":"James","age":24}
>>> person.get("name")
'James'
items(self)
所有项的列表形式
>>> person = {"name":"James","age":24}
>>> person.items()
dict_items([('name', 'James'), ('age', 24)])
keys(self)
所有的key列表
>>> person = {"name":"James","age":24}
>>> person.keys()
dict_keys(['name', 'age'])
pop(self, k, d=None)
获取并在字典中移除
>>> person = {"name":"James","age":24}
>>> person.pop("name")
'James'
>>> print(person)
{'age': 24}
popitem(self)
获取并在字典中移除
>>> person = {"name":"James","age":24}
>>> person.popitem()
('name', 'James')
>>> print(person)
{'age': 24}
setdefault(self, k, d=None)
如果key不存在，则创建，如果存在，则返回已存在的值且不修改
>>> person = {"name":"James","age":24}
>>> person.setdefault("name")
'James'
>>> person.setdefault("sex")
>>> print(person)
{'name': 'James', 'age': 24, 'sex': None}
update(self, E=None, **F)
更新
>>> person1 = {"name":"James","age":24}
>>> person2 = {"tel":""}
>>> person1.update(person2)
>>> print(person1)
{'name': 'James', 'age': 24, 'tel': ''}
values(self)
所有的值
>>> person = {"name":"James","age":24}
>>> person.values()
dict_values(['James', 24])
2 其他
2.1 运算符
- 三元运算符（三目运算符）
result = 值1 if 条件 else 值2 #如果条件成立，那么讲“值1”赋值给result变量，否则将“值2”赋值给result变量。
如下实例：
>>> result = "James" if 2<3 else "Kobe"
>>> print(result)
James
>>> result = "James" if 2>3 else "Kobe"
>>> print(result)
Kobe
- 算术运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 - 两个对象相加 | a + b 输出结果 30 |
| - | 减 - 得到负数或是一个数减去另一个数 | a - b 输出结果 -10 |
| * | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 | a * b 输出结果 200 |
| / | 除 - x除以y | b / a 输出结果 2 |
| % | 取模 - 返回除法的余数 | b % a 输出结果 0 |
| ** | 幂 - 返回x的y次幂 | a**b 为10的20次方， 输出结果 100000000000000000000 |
| // | 取整除 - 返回商的整数部分 | 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0 |
如下实例：
#!/usr/bin/env python
# -*- coding:UTF-8 -*- a = 21
b = 10
c = 0 c = a + b
print("1 - c 的值为：", c) c = a - b
print("2 - c 的值为：", c) c = a * b
print("3 - c 的值为：", c) c = a / b
print("4 - c 的值为：", c) c = a % b
print("5 - c 的值为：", c) # 修改变量 a 、b 、c
a = 2
b = 3
c = a**b
print("6 - c 的值为：", c) a = 10
b = 5
c = a//b
print("7 - c 的值为：", c)
输出结果：
1 - c 的值为： 31
2 - c 的值为： 11
3 - c 的值为： 210
4 - c 的值为： 2.1
5 - c 的值为： 1
6 - c 的值为： 8
7 - c 的值为： 2
- 比较运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于 - 比较对象是否相等 | (a == b) 返回 False。 |
| != | 不等于 - 比较两个对象是否不相等 | (a != b) 返回 true. |
| <> | 不等于 - 比较两个对象是否不相等 | (a <> b) 返回 true。这个运算符类似 != 。 |
| > | 大于 - 返回x是否大于y | (a > b) 返回 False。 |
| < | 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。 | (a < b) 返回 true。 |
| >= | 大于等于 - 返回x是否大于等于y。 | (a >= b) 返回 False。 |
| <= | 小于等于 - 返回x是否小于等于y。 | (a <= b) 返回 true。 |
如下实例：
# -*- coding:UTF-8 -*- a = 21
b = 10
c = 0 if ( a == b ):
print("1 - a 等于 b")
else:
print("1 - a 不等于 b") if ( a != b ):
print("2 - a 不等于 b")
else:
print("2 - a 等于 b") if ( a != b ):
print("3 - a 不等于 b")
else:
print("3 - a 等于 b") if ( a < b ):
print("4 - a 小于 b")
else:
print("4 - a 大于等于 b") if ( a > b ):
print("5 - a 大于 b")
else:
print("5 - a 小于等于 b") # 修改变量 a 和 b 的值
a = 5;
b = 20;
if ( a <= b ):
print("6 - a 小于等于 b")
else:
print("6 - a 大于 b") if ( b >= a ):
print("7 - b 大于等于 b")
else:
print("7 - b 小于 b")
输出结果：
1 - a 不等于 b
2 - a 不等于 b
3 - a 不等于 b
4 - a 大于等于 b
5 - a 大于 b
6 - a 小于等于 b
7 - b 大于等于 b
- 赋值运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
| += | 加法赋值运算符 | c += a 等效于 c = c + a |
| -= | 减法赋值运算符 | c -= a 等效于 c = c - a |
| *= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
| /= | 除法赋值运算符 | c /= a 等效于 c = c / a |
| %= | 取模赋值运算符 | c %= a 等效于 c = c % a |
| **= | 幂赋值运算符 | c **= a 等效于 c = c ** a |
| //= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
如下实例：
#!/usr/bin/env python
# -*- coding:UTF-8 -*- a = 21
b = 10
c = 0 c = a + b
print("1 - c 的值为：", c) c += a
print("2 - c 的值为：", c) c *= a
print("3 - c 的值为：", c) c /= a
print("4 - c 的值为：", c) c = 2
c %= a
print("5 - c 的值为：", c) c **= a
print("6 - c 的值为：", c) c //= a
print("7 - c 的值为：", c)
输出结果：
1 - c 的值为： 31
2 - c 的值为： 52
3 - c 的值为： 1092
4 - c 的值为： 52.0
5 - c 的值为： 2
6 - c 的值为： 2097152
7 - c 的值为： 99864
- 位运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 | (a & b) 输出结果 12 ，二进制解释： 0000 1100 |
| | | 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 | (a | b) 输出结果 61 ，二进制解释： 0011 1101 |
| ^ | 按位异或运算符：当两对应的二进位相异时，结果为1 | (a ^ b) 输出结果 49 ，二进制解释： 0011 0001 |
| ~ | 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 | (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。 |
| << | 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 | a << 2 输出结果 240 ，二进制解释： 1111 0000 |
| >> | 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数 | a >> 2 输出结果 15 ，二进制解释： 0000 1111 |
如下实例：
#!/usr/bin/env python
# -*- coding:UTF-8 -*- a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = 0 c = a & b; # 12 = 0000 1100
print("1 - c 的值为：", c) c = a | b; # 61 = 0011 1101
print("2 - c 的值为：", c) c = a ^ b; # 49 = 0011 0001
print("3 - c 的值为：", c) c = ~a; # -61 = 1100 0011
print("4 - c 的值为：", c) c = a << 2; # 240 = 1111 0000
print("5 - c 的值为：", c) c = a >> 2; # 15 = 0000 1111
print("6 - c 的值为：", c)
输出结果：
1 - c 的值为： 12
2 - c 的值为： 61
3 - c 的值为： 49
4 - c 的值为： -61
5 - c 的值为： 240
6 - c 的值为： 15
- 逻辑运算符
| 运算符 | 逻辑表达式 | 描述 | 实例 |
|---|---|---|---|
| and | x and y | 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 | (a and b) 返回 20。 |
| or | x or y | 布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。 | (a or b) 返回 10。 |
| not | not x | 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 | not(a and b) 返回 False |
如下实例：
#!/usr/bin/env python
# -*- coding:UTF-8 -*- a = 10
b = 20 if ( a and b ):
print("1 - 变量 a 和 b 都为 true")
else:
print("1 - 变量 a 和 b 有一个不为 true") if ( a or b ):
print("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
print("2 - 变量 a 和 b 都不为 true") # 修改变量 a 的值
a = 0
if ( a and b ):
print("3 - 变量 a 和 b 都为 true")
else:
print("3 - 变量 a 和 b 有一个不为 true") if ( a or b ):
print("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
print("4 - 变量 a 和 b 都不为 true") if not( a and b ):
print("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
else:
print("5 - 变量 a 和 b 都为 true")
输出结果：
1 - 变量 a 和 b 都为 true
2 - 变量 a 和 b 都为 true，或其中一个变量为 true
3 - 变量 a 和 b 有一个不为 true
4 - 变量 a 和 b 都为 true，或其中一个变量为 true
5 - 变量 a 和 b 都为 false，或其中一个变量为 false
- 成员运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
| not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
如下实例：
#!/usr/bin/env python
# -*- coding:UTF-8 -*- a = 10
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 的值
a = 2
if ( a in list ):
print("3 - 变量 a 在给定的列表中 list 中")
else:
print("3 - 变量 a 不在给定的列表中 list 中")
输出结果：
1 - 变量 a 不在给定的列表中 list 中
2 - 变量 b 不在给定的列表中 list 中
3 - 变量 a 在给定的列表中 list 中
- 身份运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| is | is是判断两个标识符是不是引用自一个对象 | x is y, 如果 id(x) 等于 id(y) , is 返回结果 1 |
| is not | is not是判断两个标识符是不是引用自不同对象 | x is not y, 如果 id(x) 不等于 id(y). is not 返回结果 1 |
如下实例：
#!/usr/bin/env python
# -*- coding:UTF-8 -*- 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 没有相同的标识") # 修改变量 b 的值
b = 30
if ( a is b ):
print("3 - a 和 b 有相同的标识")
else:
print("3 - a 和 b 没有相同的标识") if ( a is not b ):
print("4 - a 和 b 没有相同的标识")
else:
print("4 - a 和 b 有相同的标识")
输出结果：
1 - a 和 b 有相同的标识
2 - a 和 b 有相同的标识
3 - a 和 b 没有相同的标识
4 - a 和 b 没有相同的标识
- 运算符优先级
| 运算符 | 描述 |
|---|---|
| ** | 指数 (最高优先级) |
| ~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法减法 |
| >> << | 右移，左移运算符 |
| & | 位 'AND' |
| ^ | | 位运算符 |
| <= < > >= | 比较运算符 |
| <> == != | 等于运算符 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| is is not | 身份运算符 |
| in not in | 成员运算符 |
| not or and | 逻辑运算符 |
如下实例：
#!/usr/bin/env python
# -*- coding:UTF-8 -*- a = 20
b = 10
c = 15
d = 5
e = 0 e = (a + b) * c / d #( 30 * 15 ) / 5
print("(a + b) * c / d 运算结果为：", e) e = ((a + b) * c) / d # (30 * 15 ) / 5
print("((a + b) * c) / d 运算结果为：", e) e = (a + b) * (c / d); # (30) * (15/5)
print("(a + b) * (c / d) 运算结果为：", e) e = a + (b * c) / d; # 20 + (150/5)
print("a + (b * c) / d 运算结果为：", e)
输出结果：
(a + b) * c / d 运算结果为： 90.0
((a + b) * c) / d 运算结果为： 90.0
(a + b) * (c / d) 运算结果为： 90.0
a + (b * c) / d 运算结果为： 50.0
2.2 集合
集合（set）是一个无序的，不重复的数据组合，它的主要作用如下：
- 去重：把一个列表变成集合，就会自动去重
- 关系测试：测试两组数据之前的交集、差集、并集等关系
创建集合：
>>> name = {"James","Kobe","Yao","James"}
>>> print(name)
{'Kobe', 'James', 'Yao'}
>>> type(name)
<class 'set'>
或者：
>>> name = set({"James","Kobe","Yao","James"})
>>> print(name)
{'Kobe', 'James', 'Yao'}
>>> type(name)
<class 'set'>
clear(self, *args, **kwargs)
清除内容
>>> name = {"James","Kobe","Yao","James"}
>>> print(name)
{'Kobe', 'James', 'Yao'}
>>> name.clear()
>>> print(name)清除内容
set()
copy(self, *args, **kwargs)
浅拷贝
>>> name1 = {"James","Kobe","Yao","James"}
>>> print(name1)
{'Kobe', 'James', 'Yao'}
>>> name2 = name1.copy()
>>> print(name2)
{'Kobe', 'James', 'Yao'}
>>> id(name1)
3082730828
>>> id(name2)
3082730268
difference(self, *args, **kwargs)
name2中存在，name1中不存在
>>> name1 = {"James","Kobe","Yao","James"}
>>> name2 = {"James","Henry","Ronaldo"}
>>> name2.difference(name1)
{'Ronaldo', 'Henry'}
difference_update(self, *args, **kwargs)
从当前集合中删除和另一集合中相同的元素
>>> name1 = {"James","Kobe","Yao","James"}
>>> name2 = {"James","Henry","Ronaldo"}
>>> name2.difference_update(name1)
>>> print(name2)
{'Ronaldo', 'Henry'}
discard(self, *args, **kwargs)
移除指定元素，不存在不报错
>>> name = {"James","Kobe","Yao"}
>>> name.discard("Kobe")
>>> print(name)
{'James', 'Yao'}
intersection(self, *args, **kwargs)
交集
>>> name1 = {"James","Kobe","Yao"}
>>> name2 = {"James","Henry","Ronaldo"}
>>> name2.intersection(name1)
{'James'}
intersection_update(self, *args, **kwargs)
取交集并更新
>>> name1 = {"James","Kobe","Yao"}
>>> name2 = {"James","Henry","Ronaldo"}
>>> name2.intersection_update(name1)
>>> print(name2)
{'James'}
isdisjoint(self, *args, **kwargs)
如果没有交集，返回True，否则返回False
name1 = {"James","Kobe","Yao"}
name2 = {"James","Henry","Ronaldo"}
name2.isdisjoint(name1)
issubset(self, *args, **kwargs)
是否是子序列
>>> name1 = {"James","Kobe","Yao"}
>>> name2 = {"James"}
>>> name2.issubset(name1)
True
issuperset(self, *args, **kwargs)
是否是父序列
>>> name1 = {"James","Kobe","Yao"}
>>> name2 = {"James"}
>>> name1.issuperset(name2)
True
pop(self, *args, **kwargs)
移除元素
>>> name = {"James","Kobe","Yao"}
>>> name.pop()
'Kobe'
>>> print(name)
{'James', 'Yao'}
remove(self, *args, **kwargs)
移除指定元素，若不存在，则报错
>>> name = {"James","Kobe","Yao"}
>>> name.remove("James")
>>> print(name)
{'Kobe', 'Yao'}
symmetric_difference(self, *args, **kwargs)
对称差集
>>> name2 = {"James","Henry","Ronaldo"}
>>> name1 = {"James","Kobe","Yao"}
>>> name1.symmetric_difference(name2)
{'Kobe', 'Ronaldo', 'Yao', 'Henry'}
symmetric_difference_update(self, *args, **kwargs):
对称差集并更新
>>> name2 = {"James","Henry","Ronaldo"}
>>> name1 = {"James","Kobe","Yao"}
>>> name1.symmetric_difference_update(name2)
>>> print(name1)
{'Kobe', 'Ronaldo', 'Yao', 'Henry'}
>>>
union(self, *args, **kwargs)
并集
>>> name2 = {"James","Henry","Ronaldo"}
>>> name1 = {"James","Kobe","Yao"}
>>> name1.union(name2)
{'Kobe', 'James', 'Ronaldo', 'Yao', 'Henry'}
update(self, *args, **kwargs)
更新
>>> name2 = {"James","Henry","Ronaldo"}
>>> name1 = {"James","Kobe","Yao"}
>>> name1.update(name2)
>>> print(name1)
{'Kobe', 'James', 'Ronaldo', 'Yao', 'Henry'}
2.3 文件操作
open函数，该函数用于文件处理
操作文件时，一般需要经历如下步骤：
- 打开文件
- 操作文件
- 关闭文件
2.3.1 打开文件
打开文件时，需要指定文件路径和以何等方式打开文件，打开后，即可获取该文件句柄，通过此文件句柄对该文件操作。
文件句柄 = open("文件路径","模式")
打开文件的模式有：
- r ，只读模式【默认】
- w，只写模式【不可读；不存在则创建；存在则清空内容；】
- x， 只写模式【不可读；不存在则创建，存在则报错】
- a， 追加模式【可读； 不存在则创建；存在则只追加内容；】
"+" 表示可以同时读写某个文件
- r+， 读写【可读，可写】
- w+，写读【可读，可写】
- x+ ，写读【可读，可写】
- a+， 写读【可读，可写】
"b"表示以字节的方式操作
- rb 或 r+b
- wb 或 w+b
- xb 或 w+b
- ab 或 a+b
注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型
程序：购物车程序
需求:
启动程序后，让用户输入工资，然后打印商品列表
允许用户根据商品编号购买商品
用户选择商品后，检测余额是否够，够就直接扣款，不够就提醒
可随时退出，退出时，打印已购买商品和余额
程序: 三级菜单
要求:
打印省、市、县三级菜单
可返回上一级
可随时退出程序
1、for循环
用户按照顺序循环可迭代对象中的内容，
PS：break、continue
|
1
2
3
|
li = [11,22,33,44]
for item in li:
print item
|
2、enumrate
为可迭代的对象添加序号
|
1
2
3
|
li = [11,22,33]
for k,v in enumerate(li, 1):
print(k,v)
|
3、range和xrange
指定范围，生成指定的数字
|
1
2
3
4
5
6
7
8
|
print range(1, 10)
# 结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]print range(1, 10, 2)
# 结果：[1, 3, 5, 7, 9]print range(30, 0, -2)
# 结果：[30, 28, 26, 24, 22, 20, 18, 16, 14, 12, 10, 8, 6, 4, 2] |