PythonBasic
Python程序的组成
程序由模块组成
模块由语句、函数、类、数据等组成
语句包含表达式
表达式建立并处理数据对象
Python运行
1、python3 hello.py
2、（前提：文件内加上#！ /usr/bin/python3）
chomd u+x hello.py 之后用 ./hello.py
Python的交互提示模式
退出：ctrl+d / exit
# 井号开头，注释
Python核心数据类型
数字（int；float；复数complex（real、image）；布尔类型）
字符串
列表等
整型数int
整型数是不带小数部分的数字。包括自然数、0、负数
如：-5、10000、0等
进制：
十进制：10，20，
二进制：0b开头，后面跟0～1
0b111；0b101；0b1111
八进制：0o开头，后面跟0～7
0o177 #127
0o11 #9
十六进制：0x开头，后面给0～9，A～F，a～f
0x11 #17
0xFF #255
ox1234ABCD
进制转换：
十进制（十进一）
二进制（二进一）
八进制（八进一）
十六进制（十六进一）
二进制转八进制：三个数为一组
0b 11 011 001
0o
3
3
1
二进制转十六进制：四个数为一组
0b 1101 1001
0x d 9
hex(i)
将整数转换为十六进制字符串
oct(i)
将整数转换为八进制字符串
bin(i)
将整数转换为二进制字符串
浮点型数float
浮点型数是带有小数部分的数字
表示形式：
小数形式：3.14、3.1、3.、0.14、.14
科学计数法：e/E（正负号）指数：6.18E-1=0.618
复数complex
分为两部分：
实部（real）
虚部（image）虚部以j或J结尾
字面值：1j、(2j)、1+1J、3-4j、(-100+100J)
布尔类型数bool
用来表示真和假两个状态的类型
True 表示真、值为1（条件满足或成立）
Flase表示假、值为0（条件不满足或不成立）
空值None
None是一个表示不存在的特殊对象
作用：用来占位、用来变量解除绑定
表达式和运算符（也叫操作符）
表达式expressioin
有一个数字或数字和运算符组成
作用：通常让计算机是做一些事情并返回结果
例如：1 + 2
运算符：
算术运算符：+、-、*、/、//、%、**
除法：得到的是浮点数，不会丢失小数部分
1/3 = 0.3333333333333333
4/2 = 2.0
地板除：除到的结果去掉小数部分向下取整
7/3 = 2.3333333333333335
7//3= 2
8//3= 2
3.25//1.5=2.0
求余（取模）：
10 % 3 = 1
3.25 % 1.5 = 0.25
幂运算：
x ** y
4 ** 2 = 16
3.0 ** 4.0 = 27
5.6 ** 1.418 = 11.506165654866916
运算符的优先级
**
*
/
//
%
+
-
括号分组子表达式
用()可以将表达式分组，()内的表达式先进行计算
混合类型自动升级
1 + 2.14 返回浮点数3.14
variable 变量
作用：变量是用来绑定数据对象的标识符
方法：
1、变量名必须为数字或下划线开头，后跟字母或下划线或数字
2、不能使用python的关键字做变量名
合法示例：a a1 b bbb _aaa _Abcd var a1b2c2
不合法示例：1a 123 $ABC +a -b #ab @ab
python关键字：True, False, None, is, del, if, elif等
statement 赋值语句
语法：
变量名 = 表达式
变量名1 = 变量名2 = 表达式
变量名1, 变量名2, …… = 序列
作用：
用于创建变量并将变量绑定（或关联）在一个对象上
说明：
1、当变量不存在时，创建该变量同时绑定在这个对象上
2、当变量存在时，改变次此量绑定的对象
3、一个变量只能绑定一个对象
4、两个变量可以同时绑定同一个对象
示例：
a = 10 # 创建一个变量，和10绑定在一起
b = 20
c = a + b # 创建变量c，和10+20的结果绑定在一起
a1 = b2 = c1 = 100
关联、绑定、引用的含义
在python中，变量没有类型
关联、绑定、引用都是指变量和一个对象的关联关系
在交互模式下查看变量绑定关系：help('__main__')
自动化内存管理
a = 10000
创建“10000”数据对象在内存；a和10000相关联（通过a找到10000）；
b = 20000
创建“20000”数据对象在内存；a和10000相关联（通过b找到20000）；
a = a + b
创建“30000”数据对象在内存；a和30000相关联（通过a找到30000）； 10000被销毁
python的内存管理和引用计数
每个对象都会记录有几个变量引用自身，当引用的数量为0时，则对象被销毁，此种自动化内存管理方式叫做引用计数
序列赋值
变量名1, 变量名2, …… = 对象1, 对象2, ……
变量名1, 变量名2, …… = (对象1, 对象2, ……)
变量名1, 变量名2, …… = [对象1, 对象2, ……]
x, y = 1, 2
变量的交换绑定
a, b = b, a
is / is not 运算符
作用：判断两个对象是否绑定同一个对象，如果是同一个对象，返回True，否则False。is not相反。
语法：
a = b = 10000
s is b # True
a = 10000
b = 10000
a is b # False，因为创建了新的对象，他们绑定的不是同一个对象
小整数对象池：Cpython中整数-5～256永远存在与小整数对象池中，不会释放，会重复使用。
a = 5
b = 5
a is b # True，因为在小整数对象池中的对象
id() 函数
作用：返回一个对象在内存中的地址
格式：id(对象)
del 语句
作用：用于删除变量，同时删除与对象的关联关系。如果可能则释放对象。
语法：del 变量名
python的内存管理和引用计数
每个对象都会记录有几个变量引用自身，当引用的数量为0时，则对象被销毁，此种自动化内存管理方式叫做引用计数(reference count)
复合赋值算数运算符
y += x 等同于 y = y + x
y -= x 等同于 y = y - x
y *= x 等同于 y = y * x
y /= x 等同于 y = y / x
y %= x 等同于 y = y % x
比较运算符
<
<=
>
>=
==
!=
语法：
左表达式 < 右表达式
说明：
比较运算符返回布尔类型的值
示例：
10 < 20 # True
1 + 10 > 2 + 8 # True
10 < 20 <= 30 # True
数值对象的构造函数
float(obj)
用字符串或数字转换为浮点数，如果不给出参数则返回0
int(x,base=10) 或 int(x=0); base是进制
用数字或字符串转换为整数，如果不给出参数，则返回0
compx(r=0.0, i=0.0)
用数字或字符创建一个复数
bool(x)
用x创建一个布尔值(True/False)
返回假值的情况
None 空
False 假
0, 0.0, 0j
''
()
[]
{}
set()
函数调用
函数名(传参列表)
说明：
函数调用是表达式，一定会返回一个对象的引用关系
内建数值型函数
abs()
取绝对值
round(x[, ndigits]) 四舍五入；ndigits正数时是向右取整的位数
round(x, -1)
pow(x, y) x ** y
help() 函数
作用：查看函数帮助文档
用法：help(函数名)
statement 语句
语句是有一些表达式等组成，通过一条语句可以独立执行来完成一部分事情并形成结果
一天语句建议写在一行内
多条语句写在一行内需要用分号(;)分开
示例：
print("hello")
x = 100 + 200
print(x)
del x
换行：
显式换行 \
隐式换行 括号内换行() [] {}
示例：
i = 1 + 2 + 3 \
+ 4 + 5
i = (1 + 2 + 3
+ 4 + 5)
input() 基本输入函数
作用：从标准输入设置上读取一个字符串（末尾的换行符会被删除）
格式：input("提示字符串")
说明：返回输入的字符串（仅python3）“提示字符串”可以为空
示例：
s = input("请输入字符串:")
print("您输入的字符串是:", s)
print(1+int(s)) 转换整形
print() 基本输出函数
作用：将以系列的值以字符串形式输出到标准输出设备上，默认是终端
格式：print(要打印的数据)；各数据可以用逗号分隔开
示例：
print(1+2)
print("hello")
print("1 + 2 =", 1 + 2)
print(value,value, sep=''（分隔符号默认空格）,end='\n')
if 语句
作用：让程序根据条件选择的执行某条语句或某些语句
说明：if语句又叫做条件语句，也叫分支语句
语法：
if 真表达式1:
语句块
elif 真表达式2:
语句块2
elif 真表达式3:
语句块3
……
else:
语句块4
elif可以有多个；else只能有0个或1个；
要求：if语句内部的语句通常要以4个空格的是缩进来表示包含关系，相同的缩进格式代表相同的所属级别
s = input("请再输入字符串:")
j = int(s)
if j > 100:
print("Bigger than 100")
elif 0 < j < 20:
print("Between 0 and 20")
else:
print("Other")
if 语句的真值表达式
if 100:
print("真值")
# 等同于
if bool(100):
print("真值")
if 语句嵌套
if语句本身是由多条字句组成的一条复合语句
if语句可以作为语句嵌套到另一个语句的内部
if 1 <= month <= 12:
print("是合法的月份")
if month <= 3:
print("是春季")
elif....
else:....
条件表达式
作用：如果真值表达式的布尔环境值为True，则执行表达式1并返回结果的引用，否则执行表达式2并返回结果的引用
语法：表达式1 if 真值表达式 else 表达式2
示例：
商场促销满100减20
money = int(input("请输入商品总额"))
pay = money - 20 if money >= 100 else money
print("您需要支付", pay, "元")
pass 语句
作用：通常来填充语法空白，又名空语句
语法：psss
示例：
g = int(input("请输入学生的成绩"))
if 0 <= g <= 100:
psss
else:print("不处于成绩范围")
布尔运算
运算符：
not and or
布尔非操作：not
语法：not x
作用：对x进行布尔取值，如bool(x)，为True，返回False，否则返回True
示例：
not True = False
not 100 = False
布尔与操作：and
语法：x and y
作用：优先返回假值对象，当bool(x)的为False时，返回x，否则返回y
示例：
True and True = True
True and False = False
100 and 200 = 200
布尔或操作：or
语法：x or y
作用：优先返回真值对象，当x为True时返回x，否则返回y
100 or 200 = 100 （都为真优先返回左侧的）
应用：
sore = int(input("请输入成绩：") or '0')
if score < 0 or score > 100:
print("您的成绩不合法！！！")
else:
print("您输入的成绩是：", score)
正负号运算符
+（正号） -（负号）
语法：
+ 表达式
- 表达式
示例：
a = 5
b = -a
str 字符串
作用：用来记录文本（文字）信息
表示方法：
' 单引号
" 双引号
单引号和双引号的区别：
单引号内的双引号不算结束符
双引号内的单引号不算结束符
''' 三单引号
""" 三双引号
三引号字符串：
三引号字符串换行会自动转换为换行符'\n'
三引号内可以包含单引号和双引号
s = '''Welcome to Beijing
I like Python!
I am learning!'''
print('Welcome to Beijing\nI like Python!\nI am learning!')
用转义序列代表特殊字符
字符串字面值中，用字符反斜杠后跟一些字符代表一个字符
字符串中的转义字符表
\' \" \\
\n \r(光标返回行首并替换) \f(换页) \t(水平制表符) \v(垂直制表符)
\b(倒退、删除) \0(空字符)
\0oo(oo为两位八进制表示的字符)
\xXX(XX为两位十六进制表示的字符)
\uXXXX(Unicode16的十六进制表示的字符)
\uXXXXXXXX(Unicode16的十六进制表示的字符)
ASCII编码
man ascii (八进制十六进制都可以表示)
常用ASCII：
字符 十进制 十六进制
'0' 48 0x30
'A' 65 0x41
'a' 97 0x61
ord(c) 返回一个字符串的Unicode
chr(i) 返回i这个值所对应的字符
print(ord('A')) # 65
print(ord('中'))# 20013
raw 字符串（原始字符串）
字面格式：r'字符串内容'(""","")
作用：让转义字符\无效
示例：
a = 'C:\newfile\test.py'
print(a)
print(len(a))
a = r'C:\newfile\test.py'
print(a)
print(len(a))
字符串的运算
算术运算符：
+ += * *=
+ 加号运算符用于字符串的拼接
x = 'abcd' + 'efg'
print(x)
# abcdefg
x += '123' # abcdefg123
* 运算符用于生成重复的字符串
x = '123'
y = x * 2 # y = '123123'
比较运算符：
> >= < <= == !=
示例：
'A' < 'B' # True
'B' < 'a' # True
'AD'< 'ABC' # False 从左到右依次相比
'ABC' == 'abc' # False
in / not in
作用：用于序列、字典、集合，判断某个值是否在该容器中返回TF
格式：对象 in 容器
示例：
s = 'Welcome to Ningbo!'
'to' in s #True
index 字符串的索引操作
python字符串str是不可以改变的字符序列
index 索引
索引语法：字符串[整数表达式]
说明：
python序列都可以用索引（index）来访问序列中的对象（元素）
python序列的正向索引是从0开始的，第二个索引为1，最后一个索引为len(s)-1
python序列的反向索引是从-1开始的，-1代表最后一个，-2代表倒数第二个，第一个是-len(s)
s[0] = s[-len(s)] # W
最后一个s[len(s) - 1] = s[-1]
slice 切片
作用：从字符串序列中取出一部分相应的元素重新组成一个字符串
语法：字符串[(开始索引b)]:(结束索引e):(步长s)]
注：()内括起的部分代表可以省略
说明：
1、开始索引是切片开始切下的位置0代表第一个元素，-1代表最后一个元素
2、结束索引是切片的终止索引(但不包括终止索引)
3、步长是切片每次获取完前索引后向后移动的方向和偏移量
1）没用步长，相当于取值完成后向后移动一个索引的位置（步长为1）
2）当步长为正整数时，取正向切片：
补偿默认值为1，开始索引默认值为0，结束索引的默认值为len(s)
[开始：结束：步长]
默认：[0:len(s):1]
反向：[::-1]
3）当步长为负整数时，取反向切片：
反向切片时，默认的起始位置为最后一个元素，默认中止为第一个元素的前一个位置
示例：
s = 'ABCDE'
a = s[1:4] # a -> 'BCD'
a = s[1:] # a -> 'BCDE'
a = s[:2] # a -> 'AB'
a = s[:] # a -> 'ABCDE'
a = s[1:4:2] # a -> 'BD'
a = s[::2] # a -> 'ACE'
常用的序列函数
len(seq) 返回序列长度
max(x) 返回序列最大值元素
min(x) 返回序列最小值元素
示例：
s = 'ABCDE'
len(s)
5
整数转换为字符串函数
ord(c)
返回一个字符串的Unicode编码值
chr(i)
返回i这个值所对应的字符 = %c % i
hex(i)
将整数转换为十六进制字符串
oct(i)
将整数转换为八进制字符串
bin(i)
将整数转换为二进制字符串
str() 字符串的构造、创建函数
str(obj='')
将对象转换为字符串
常见的字符串方法
调用语法：对象.方法名()
注：方法的调用属于表达式，通常可以返回一个值或None
示例：
'abc'.isalpha()
if 'abc'.isalpha():
print("True")
s.(30, '#') #给出宽度居中 默认为空格
s.count('A', 3, 5) #返回3到5的A个数
s.find()
s.strip() #去掉左右侧空白字符，lstrip，rstrip
s.upper() #返回大写
s.lower() #返回小写
s.replace(old, new, 个数)
s.startwith() #判断开头
s.endswith() #判断结尾
s.title() #将开头变成大写
字符串格式化表达式
运算符：%
作用：生成一定格式的字符串
语法：
格式字符串 % 参数值
格式字符串 % (参数值1,参数值2,……)
格式字符串中的%为占位符
示例：
fmt = "姓名:%s, 年龄:%d"
name = input("请输入姓名：")
age = int(input("请输入年龄："))
s = fmt % (name, age)
print(s)
格式化字符串中的占位符和类型码
占位符
意义
%s
字符串用str转换
%r
字符串用repr转换
%c
整数转换为单个字符
%d
十进制整数
%o
八进制整数
%x
十六进制整数（a-f小写）
%X
十六进制整数（a-f大写）
%e
指数型浮点数（e小写）
%E
指数型浮点数（E大写）
%f
浮点十进制
%g
自动转换指数
%%
%
占位符和类型码之间的各式语法
语法：% [格式语法] 类型码
- 左对齐
+ 显示正号
0 补零
宽度（整数）
宽度.精度(整数)
例如：
'%10d' % 123 # ' 123'
'%-+10d'% 123 # '+123 '
'%010d'% 123 # '0000000000123'
'%7.3f' % 3.1415926
format 函数格式化字符串
s = "I love {}".format("WW")
print(s)
s1 = "I love {0} and {1}".format("haha",99)
s2 = "haha {0}"
s2.format("shibushi")
while 循环语句
作用：根据一定条件，重复的执行一条语句或多条语句
语法：
while 真表达式:
语句
else:
语句
1、先执行真值表达式，判断True/False
2、如果为True则执行语句快1，然后跳转到第一步
3、如果为False则执行else字句部分的语句快2，然后结束此while语句的执行，如果没有else子句，则直接结束此while语句
4、else子句部分可以省略（同if语句类似）
注意事项：
1、要控制真值表达式来防止死循环
2、通常用真值表达式内的变量来控制循环条件
3、通常要在循环语句快内改变循环变量来控制熏昏的次数和变量的走向
示例1：
i = 1
while i < 5:
print("Hello World!")
i += 1
else:
print("条件不足，此时变量i=%d，循环结束" % i)
示例2: 只用一个变量
while 1 <= n:
print("Hello World!")
n -= 1
else:
print("条件不足，此时变量n=%d，循环结束" % n)
示例3:用while语句打印1～20的整数（包含20）
i = 1
while i <= 20:
print(i)
i += 1
print("End!")
while 语句嵌套
while语句本身是语句，和其他语句一样，可以放在其他符合语句的内部
语法：
while 真值表达式:
……
while 真值表达式2:
……
else:
……
……
else:
……
j = 1
while j <= 10:
i = 1
while i <= 20:
print(i, end=' ')
i += 1
print("End!")
j += 1
break 语句：
作用：用于while、for语句中止当前循环的语句，常常和if连用
说明：
1、当break语句执行后，此循环语句break之后的语句将不再执行
2、break语句通常和if语句组合使用
3、break语句中止循环时，循环语句的else子句的语句将不会执行
4、break语句只能终止当前循环语句的执行，如果有循环嵌套时，不会跳出嵌套的外重循环
5、break语句只能在循环语句中（while或for）内部使用
示例：
i = 1
while i <= 6:
print("本次循环开始时：", i)
if i ==3:
break
print("本次循环结束时：", i)
i += 1
死循环
概念：死循环是指循环条件一直成立的循环、通常用break语句来中止循环，死循环的else子句永远不会执行
示例：
while True:
n = int(input("请输入"))
if n == 0:
break
print(n)
for 语句
作用：用来遍历可迭代对象的数据元素，可迭代对象是指能以此获取数据元素的对象，可迭代对象包括：
字符串str、列表list、元组tuple、字典dict、集合set……
语法：
for 变量列表 in 可迭代对象：
语句快1
else: (结束循环后)
语句快2
说明：
1、可迭代对象每次提供一个元素依次赋值给变量列表中的变量，赋值完毕后执行语句块1，重复执行此步骤，直到可迭代对象不能提供数据为止。
2、可迭代对象提供完所有元素后，执行else子句部分的语句快2，然后退出此for语句。
3、else子句部分可以省略（同while类似）。
4、当在循环内部使用break中止循环时，else子句部分语句不会执行。
示例：
s = 'ABCDE'
for ch in s:
print("ch--->", ch)
else:
print("for语句执行else语句")
print("程序退出")
for 语句嵌套
for 语句内部可以放冉义语句，包含for语句和while语句
示例：
for x in 'ABC':
for y in '123':
print(x+y)
count = 0
for x in range(5):
for y in range(10):
count += 1
print(count)
range() 函数
格式见：help(range)
作用：用来创建一个生成一系列整数的迭代对象（也叫做整数序列生成器）
函数：
range(stop)从零开始，每次生成一个整数后加1操作，直到stop为止（不包含stop）
rang(start, stop[, step])
从start开始，每次生成一个整数后移动step，直到stop为止（不包含stop，且step可以是负数）
说明：range返回的对象是可迭代对象，可以用于for语句中
示例：
range(4)
# 0, 1, 2, 3
range(3, 6)
# 3, 4, 5
range(1, 10, 2) # 1, 3, 5, 7, 9
range(5, 0 , -2)# 5, 3, 1
range(4, 0)
# 空
for x in range(4):
print(x)
for x in range(3, 6):
print(x)
continue 语句
作用：用于循环语句（while、for）中，不再执行本次循环内continue之后的语句，重新开始一次新的循环
说明：
1、在while语句中，执行continue语句将会直接跳转到while语句的真值表达式处重新判断循环条件
2、在for语句中，执行continue语句，将会从可迭代对象中取下一个元素，绑定变量后再次进行循环
示例：
for x in range(5):
if x == 2:
continue
print(x)
sequence 序列类型
字符串 str
列表 list
元组 tuple
字节串 bytes
字节数组 bytearray
list 列表
概念：列表式由一系列特定元素组成的，元素和元素之间没有任何关联关系，但他们之间有先后顺序关系。列表式一种容器，是序列的一种，是可以被改变的序列
创建列表：
L = [] # 空列表
L = [1, 2, 3, 4]
L = ["北京", "上海", "重庆"]
L = [1, 'two', 3, '四']
L = [1, 2, [3.1, 3.2, 3.3], 4]
构造函数：list()、list(interable) 用可迭代对象创建一个列表
L = list(range(1, 10, 2))
L = list("ABCD")
list 运算
算术运算：
+ += * *=
+ 用于拼接
x = [1, 2, 3]
y = [4, 5, 6]
z = x + y (拼接)
+= 用于愿列表与右侧的可迭代对象进行拼接，生成新的列表
x += [4,5,6] -> [1,2,3,4,5,6]
x += 'ABC' -> [1,2,3,4,5,6,'A','B','C']
* 用于生成重复的列表
x = [1, 2]
x *= 3 # x = [1,2,1,2,1,2]
比较运算：
< <= > >= == !=
x = [1,2,3]
y = [2,3,4]
x != y # True
x > [1,2] #True
x < y #True
[1,3,2] > [1,2,3] # True
['AB', 'CD'] > ['AC', 'BD'] #False
[1, 'two'] > ['two', 1] # Typeerror
list in / not in
作用：判断一个数据元素是否怒在容器（列表内），如果存在，返回True，否则返回False
示例：
x = [1. 'Two', 3.14, '四']
1 in x # True
2 in x # True
'四' not in x # False
list index / slice
取值语法：列表[整数表达式]
取值用法：列表的索引取值与字符串的索引取值规则完全相同，列表的索引为分正向索引和反向索引
x = list(range(9))
y = x[1:9:2] # y = [1, 3, 5, 7]
索引赋值：列表式可变的序列，可以通过索引赋值改变列表中地元素
索引语法：列表[索引] = 表达式
切片赋值语法：列表[切片] = 可迭代对象
说明：切片赋值的赋值运算符的右侧必须是一个可迭代对象
切出来然后再赋值
示例：
L = [2, 3, 4]
L[0:1] = [1.1, 2.2] -> [1.1, 2.2, 3, 4]
L[1:2] = [1.1, 2.2] ->
L[1:2] = []
切片不长不为1的切片赋值：
L = list(range(1, 9))
L[1::2] = [2.2, 4.4, 6.6, 8.8]
print(L)
注意事项：对于步长不等于1的切片赋值，赋值运算符的右侧的可迭代对象提供元素的个数一定要等于切片切出的段数
L += 'ABC' 会改变原有id，相当于新建变量
del 列表元素删除
语法：del 列表[index/slice]
示例：
L = [1, 2, 3, 4, 5, 6]
del L[0] #L = [2, 3, 4, 5, 6]
del L[-1] #L = [2, 3, 4, 5]
L = [1, 2, 3, 4, 5, 6]
del L[::2] # L = [2, 4, 6]
常用的序列函数
len(x)
返回序列的长度
max(x)
返回序列的最大元素
min(x)
返回序列中最小值元素
sum(x)
返回序列中所有元素的和（必须是数值类型）
any(x) 真值测试，如果列表中其中有一个值为真
all(x)
真值测试，如果所有都为真值
list 常用方法
L.index() 查询元素的索引下标
L.insert(x,y) x索引 y内容
L.count(x) 返回列表中x的个数
L.remove(x)删除第一次出现的x值
L.copy() 复制列表
L.append() 在列表中追加单个元素（排在最后）
L.extend() 追加一个列表，依次放入，类似 L+=
L.clear() 清空
L.sort(reverse=False) 按元素进行排序，默认为从小到大升序
L.reverse() 反转顺序
L.pop([index]) 删除元素，默认最后一个，会返回值
split/join 字符串文本解释方法
S.split(sep=None)
使用sep作为分隔符分隔s字符串，返回分割后的字符串列表，默认为空白字符作文分隔符
S.join(interable)
使用可迭代对象的字符串，返回一个中间用S进行分割的字符串
示例
s = 'Beijing is capital'
L = s.split() ->['Beijing', 'is', 'captial']
s = '\\'
L = ['C:', 'Programe files', 'python3']
s2 = s.join(L) -> s2 = 'C:\\Programe files\\python3'
深拷贝deep copy；浅拷贝shallow copy
浅拷贝：是指在复制过程只复制一层变量，不会复制深层变量绑定的对象的复制过程
深拷贝：深拷贝通常只对可变对象进行解释不可变对象通常不变
L = [3.1, 3.2]
L1 = [1, 2, L]
L2 = L1.copy 等同于 L1[:] 浅拷贝，改变L2[2][0]，L也会改变
import copy
L2 = copy.deepcopy(L1) 深拷贝
lsit comprehension 列表推导式
列表推导式是用可迭代对象依次生成带有多个元素的列表的表达式
作用：用简单方法生成列表
语法：
[表达式 for 变量 in 可迭代对象]
[表达式 for 变量 in 可迭代对象 if 真值表达式]
示例：
L = [x*x for x in range(1, 10)]
L = [i for i in range(1,100,2)] #打印出1-100以内的奇数
L = [i for i in range(1,100) if x % 2 ==1] #同上！！
--------------
嵌套：
[表达式1 for v1 in 迭代1 if 真表1
for v2 迭代2 if 真表2 ……]
示例：
L1 = [2, 3, 5]
L2 = [7, 11, 13]
将L1中的全部元素与L2中的全部元素一次相乘后放到L3中
L3 = [x * y for x in L1 for y in L2]
print(L3)
tuple 元组
元祖是不可改变的序列，同list一样元组可以存放任意类型的元素，一单元组生成，则他不可以改变
表示方式：用小括号()括起来，单个元素括起来用逗号，区分是单个对象还是元组。
t = ()
t = 200,
t = (20,)
t = (1, 2, 3)
t = 100, 200, 300
构造函数 tuple
tuple()生成一个空的元组，等同于()
tuple(interable) 用可迭代对象生成一个元组
示例：
t = tuple()
t = tuple(range(10))
t = tuple('hello')
t = tuple([1,2,3,4])
元组的算术运算：
+ += * *= 用法语列表的用法完全相同
元组的比较运算：
< <= > >= == != 和列表用法完全相同
in / not in 切片、索引规则与列表完全相同
区别：元组是不可变对象，不支持索引赋值和切片赋值
元祖的方法：help(tuple)
T.count(value) -> integer -- return number of occurrences of value
T.index(value, [start, [stop]]) -> integer -- return first index of value.
可以用于序列的函数
len, max, min, sum, all, any
构造函数:
str(obj)
list(interable)
tuple(interable)
其他函数：
reversed(seq) 返回反向顺序的可迭代对象
sorted(interable, reversed=False) 返回排序的可迭代对象注意区分它和.sort()方法
返回已排序的列表
示例：
for x in reversed('ABCD')；
print(x)
L = [8,]
dict 字典
1、字典是一种可变的容器，可以存储任意类型的数据
2、字典中的每个数据都是‘键’(（key)进行索引，而不像序列可以用下表来进行索引
3、字典的数据没有先后顺序关系，字典的存储是无序的
4、字典中的数以 键(key)——值(value)对 进行映射存储
5、字典的键不能重复，且只能用不可变类型作为字典的键。
字典的字面值表示方式：
用{}括起来，以冒号(:)分割 键——值对 ，各键值对 用分号(;)来分开
创建字典
d = {}
d = {'name': 'howie', 'age': 15}
d = {'姓名'： '小张'}
d = {1:'壹', 2:'贰'}
字典的构造函数
dict() 传建一个空字典，等同于{}
dict(interable) 用可迭代对象初始化一个字典
dict(**kargs) 关键字传参形式生成一个字典
示例：
d = dict()
d = dict([('name', 'Howie'), ('age', 15)])
d = dict(name = 'Howie', age = 15)
不可变类型（可以作为键）：int, float, complex, bool, str, tuple, frozensrt
可变类型：list, dict, set, bytearry（字节数组）
字典的键索引
用[]运算符可以获取字典内'键'所对应的'值'
语法：字典[键]
获取数据元素
d = dict(name='Howie', age=15)
print(d['age'])
添加、修改字典元素
字典[键] = 表达式
d = {}
d['name'] = 'Howie'
d['age'] = 15
d['age'] =16
del 语句删除字典的元素
语法：del 字典[键]
d = {'name': 'china', 'pos': 'asia'}
del d['pos']
print(d)
dict in / not in
可以用in运算符来判断一个‘键’是否存在于字典中，如果存在则返回True，否则返回False
示例：
d = {'a': 1, 'b': 2}
'a' in d # True
1 in d # False
100 not in d # True
2 not in d # True
dict 迭代访问
字典是可迭代对象，字典只能对键进行迭代访问
d = {'name': 'Howie', (2002, 1, 1): '生日'}
for x in d:
print(x)
print(d[x])
dict 方法
D.clear()
清空字典
D.pop(key)
移除键，同时返回此键所对应的值
D.copy()
返回字典D的副本,只复制一层(浅拷贝)
D.update(D2)
将字典 D2 合并到D中，如果键相同，则此键的值取D2的值作为新值
D.get(key, default)
返回键key所对应的值,如果没有此键，则返回default
D.keys()
返回可迭代的 dict_keys 集合对象
D.values()
返回可迭代的 dict_values 值对象
D.items()
返回可迭代的 dict_items 对象
示例：
for k, v in d.items():
print(k, v)
dict 推导式
字典推导式是用可迭代对象依次生成字典内元素的表达式
语法：
{键表达式 : 真值表达式 for 变量 in 可迭代对象 [if 真值表达式]}
注：[]的内容可以省略
示例：
d = {x : x ** 2 for x in range(10)}
d = {x : x ** 2 for x in range(10) if x % 3 == 0}
set 集合
集合是可变的容器
集合内的数据对象是唯一的（不能重复多次的）
集合是无序的储存结构，集合中的数据没有先后关系
集合内的元素必须是不可变对象
集合是可迭代的
集合是相当于只有键没有值的字典（键则是集合的数据）
创建集合
set()
s = {1, 2, 3}
set(interable)
示例：
s = set("ABC")
s = set('ABCCBA')
s = set({1:"一", 2:"二", 5:"五"})
s = set([1, 3.14, False])
s = set((2, 3, 5, 7))
集合的运算：
交集，并集，补集，子集，超集
& 交集：
s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 & s2 # s3 = {2,3}
| 并集：
s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 | s2 # s3 = {1,2,3,4}
对于可变对象，不等用于 s1 |= s2
- 生成两个集合的补集：生成属于s1，但不属于s2的所有元素集合
s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 - s2 # s3 = {1}
^ 生成两个集合的对称补集：
s1 = {1,2,3}
s2 = {2,3,4}
s3 = s1 ^ s2 # s3 = {1,4}
相当于 s3 = (s1-s2) | (s2-s1)
< 判断一个集合是另一个集合的子集
> 判断一个集合是另一个集合的超集
s1 = {1,2,3}
s2 = {2,3}
s2 < s1 # True s2是s1的子集
s1 > s2 # True s1是s2的超集
= ！= 判断集合相不相同
s1 = {1,2,3}
s2 = {2,3,1}
s1 == s2 # True
s1 != s2 # False
集合的数据没有先后顺序
in / not in
等同于字典，in运算符用于集合中，当某个值存在于集合中，则为真，否则为假
not in 与 in 返回值相反
示例：
s = {1, 'Two', 3.14}
1 in s # True
3.14 not in s # False
可用于集合的函数：
len(x) max(x) min(x) sum(x) any(x) all(x)
集合是可迭代对象：不保证顺序
s = {1, 2, 3}
for x in s:
print(x)
set 方法
S.add(e)
在集合中添加一个新的元素e；如果元素已经存在，则不添加
S.remove(e)
从集合中删除一个元素，如果元素不存在于集合中，则会产生一个KeyError错误
S.discard(e)
从集合S中移除一个元素e,在元素e不存在时什么都不做;
S.clear()
清空集合内的所有元素
S.copy()
将集合进行一次浅拷贝
S.pop()
从集合S中删除一个随机元素;如果此集合为空，则引发KeyError异常
S.update(s2)
用 S与s2得到的全集更新变量S
S.difference(s2)
用S - s2 运算，返回存在于在S中，但不在s2中的所有元素的集合
S.difference_update(s2)
等同于 S = S - s2
S.intersection(s2)
等同于 S & s2
S.intersection_update(s2)
等同于S = S & s2
S.isdisjoint(s2)
如果S与s2交集为空返回True,非空则返回False
S.issubset(s2)
如果S与s2交集为非空返回True,空则返回False
S.issuperset(...)
如果S为s2的子集返回True,否则返回False
S.symmetric_difference(s2)
返回对称补集,等同于 S ^ s2
S.symmetric_difference_update(s2)
用 S 与 s2 的对称补集更新 S
S.union(s2)
生成 S 与 s2的全集
set 集合推导式
用可迭代对象来创建（生成）集合的表达式
语法：
{表达式 for 变量 in 可迭代对象 [if 真值表达式]}
[]部分可以省略
示例：
L = [2,3,5,7,3,5,7,11]
s = {x ** 2 for x in L}
集合推导式的嵌套规则和列表推导式相同
{x + y for x in "ABC for y in "123"}
frozensey 固定集合
固定集合是不可变得，无序的，含有唯一元素的集合
作用：
固定集合可以作为字典的键，也可以作为集合的值（元素）
创建固定集合：
fs = frozenset()
fs = frozenset([2,3,5,7])
frozenset(interable)
固定集合的运算等同于集合运算
总结
不可变数据类型：
bool, int, float, complex, str, tuple, frozenset, bytes
可变数据类型：
list, dict, set, bytearray(字节数组)
运算符：
+ - * / // % **
> >= < <= == !=
is is not
in not in
not and or
& | ^
表达式：
1
1 + 2
len([1,2,3])
条件表达式： x if x > y else y
全部的推导式：
列表、字典、集合推导式（三种）
语句：
表达式语句：
print("ABC")
'hello'
赋值语句：
a = 100
a = b = c = 200
x, y = 100, 200
if 语句
while 语句
for 语句
break 语句
continue 语句
pass 语句
del 语句
内建函数：
len(x)
max(x)
min(x)
sum(x)
any(x)
all(x)
----------
bool(x) int(x) float(x) complex(x) str(s) list(s) dict(s) set(s) frozenset(s)
----------
bin(x)
oct(x)
hex(x)
chr(x)
----------
range([sratr, ]stop[, step])
----------
input(x)
print()