一，基本类型
类型一
查看数据类型的方法
type :查看数据类型 type(变量名)
ctrl+鼠标左键：放在需要查看的变量上可知详细内容–源码
help(type(变量名))： --当前的控制台
dir:查看类下方法名字
数字类型
int(整型)
float(浮点型)
相同类型下整数要比浮点数快
complex(复数)
int float complex 都不可以修改
数字类型的相互转化
a=2
b=3.14
c='2'
print("a的类型为",type(a))
print("b的类型为",type(b))
print("c的类型为",type(c))
#转换为整数
d=int(b)
#转换为浮点数
f=float(a)
#转化为复数
e=complex(a) 注意：若传入两个参数，前后都不允许是字符串类型的数字
其他类型
布尔值(bool)： True和False
——字符串——
单引号，双引号构成的
双引号包含单引号 例如：c="a’b’c"包含了：a ’ b ’ c 多种字符
索引（下标） 反向索引
长度（len）
切片：a[头：尾：步长] 切片时下标包头不包尾，切片时是从前向后，反向时也一样
——字符串的功能集——
| capitalize() | str | 首字母变大写 | S.capitalize() |
|---|---|---|---|
| casefold() | str | 小写 | S.casefold() |
| center(width[, fillchar]) | str | 内容居中，width：总长度；fillchar：空白处填充内容 | S.center(20,’*’) |
| count(sub[, start[, end]]) | int | 子序列个数 | s.count(‘a’) or s.count(‘a’,0,10) |
| endswith(suffix[, start[, end]]) | bool | (字符串中大于等于start小于end的位置)是否以 xxx 结束 | s.endswith(‘e’) or s.endswith(‘e’,0,6) |
| expandtabs(tabsize=8) | str | 将tab转换成空格，默认一个tab转换成8个空格 | s.expandtabs() or s.expandstabs(20) |
| find(sub[, start[, end]]) | int | 寻找子序列位置，如果没找到，返回 -1 | s.find(‘e’) |
| format(*args, **kwargs) | str | 字符串格式化，动态参数,讲函数式编程时细说 | “hello{0},age(1)".format(‘china’, 69) |
| index(sub[, start[, end]]) | int | 子序列位置，如果没找到，报错，参考find |
| 方法名 | 返回值 | 含义 | 案例 |
|---|---|---|---|
| isalnum() | bool | 是否是字母和数字 | |
| isalpha() | bool | 是否是字母 | |
| isdigit() | bool | 是否是数字 | |
| islower() | bool | 是否小写 | |
| isspace() | bool | 是否空格 | |
| istitle() | bool | 是否标题 | |
| isupper() | bool | 是否大写 | |
| join(iterable) | str | 列表拼接为字符串 | li = [“hello”,“world”] s ="-".join(li) |
| ljust(width[, fillchar]) | str | 内容左对齐，右侧填充，参考center | |
| lower() | str | 变小写 | |
| lstrip([chars]) | str | 移除左侧空白 | |
| rstrip([chars]) | str | 移除右侧空白 | |
| strip([chars]) | str | 移除两侧空白 |
| 方法名 | 返回值 | 含义 | 案例 |
|---|---|---|---|
| partition(sep) | tuple | 将字符串分割为前，中（sep），后三部分 | “hello-world”.partition("-") 返回;(‘hello’, ‘-’, ‘world’) |
| replace(old, new[, count]) | str | 替换 | “hello-world”.replace(’-’, '/’) 返回：'hello/world’ |
| split(sep=None, maxsplit=-1) | list | 分割， maxsplit最多分割几次 | “hello-world”.split("-") 返回;[‘hello’, ‘world’] |
类型二
一，列表 (list)
列表是有序的可变的元素集合 。
像字符串值用引号来标记字符串的起止一样，列表用左方括号开始，右方括号结束，即 [ ]。列表中的值也称为“表项”。
索引，切片，长度，循环与字符串一致
添加：append(object) extend(iterable) insert(index, object) 单纯的 + 号
删除：pop([index]) remove(value) clear()
循环：for
| 方法名 | 返回值 | 含义 | 案例 |
|---|---|---|---|
| append(object) | None | 追加 | L.append(“d”)print(L) |
| clear() | None | 清除 | L.clear() |
| copy() | list | 拷贝 | L.copy() |
| count(value) | int | 子元素个数,同字符串 | |
| extend(iterable) | None | 批量添加 | L1.extend(L2)print(L1) |
| index(value, [start, [stop]]) | int | 子元素位置 同字符串 | |
| insert(index, object) | None | 插入 | L.insert(1, “d”)print(L) |
| pop([index]) | item | 移除列表最后一个元素，并可将该元素赋值给新的变量 | a = L.pop()print(L)print(a) |
| remove(value) | None | 移除左边开始第一个指定元素 | L.remove(“b”)print(L) |
| reverse() | 倒置(不是排顺序，仅反转) | ||
| sort(key=None,reverse=False) | None | 排序 |
二，字典（dict）
字典是由键值对构成（key、value）的无序集合（不像字符串、列表和元祖那样有固定的位置）
键（key）的数据类型一般为数字或字符串，且必须是唯一的，不能重复。值（value）可以是任意数据类型。
字典使用大括号{ }。
——特性——
-
键(key)唯一性 ：字典中的键(key)具有唯一性，不存在两个相同的键(key)
无序性：字典中的键也是无序的，所以不能通过索引取值
可变性：字典是可变对象，但是字典的键(key)必须是不可变对象
长度：len()
键、值、键值对：
# 键、值、键值对
D = {
'k1': 'v1',
'k2': 'v2',
'k3': 'v3',
}
# items
# keys
# values
print(D.items()) # dict_items([('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')])
print(D.keys()) # dict_keys(['k1', 'k2', 'k3'])
print(D.values()) # dict_values(['v1', 'v2', 'v3'])
获取值：
# 通过key取value
print(D['k2'])
# get
print(D.get('k3'))
print(D.get("k4")) # None
print(D.get("k4", 'false')) # false
# setdefault()：key有则取，无则增
print(D.setdefault('k3'))
print(D.setdefault("k4")) # None
print(D) # {'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'k4': None}
print(D.setdefault("k5", "v5")) # v5
print(D) # {'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'k4': None, 'k5': 'v5'}
新增：
# 同上setdefault：如果key不存在，则创建，如果存在，则返回已存在的值且不修改，类似get（）
print(D.setdefault("k5", "v8"))
print(D) # {'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'k4': None, 'k5': 'v5'}
# 通过key修改
D['k2'] = 'v8'
print(D)
D['k6'] = "v6"
print(D) # {'k1': 'v1', 'k2': 'v8', 'k3': 'v3', 'k4': None, 'k5': 'v5', 'k6': 'v6'}
删除：popitem() clear() pop(k[,d])
循环：for k,v in x.items(): 注意键值对
print(k,v)
| 方法名 | 返回值 | 含义 | 案例 |
|---|---|---|---|
| clear() | None | 清除内容 | D.clear() |
| copy() | dict | 拷贝 | D.copy() |
| fromkeys() | dict | 创建字典的一种方法 | L = [1, 2, 3] print(D.fromkeys(L)) print(D.fromkeys(L, ‘v’)) |
| pop(k[,d]) | dict | 获取并在字典中移除指定key值项 | a = D.pop(‘k2’) print(a) print(D) |
| popitem() | dict | 获取并在字典中移除最后一项 | a = D.popitem() print(a) print(D) |
| get(k[,d]) | 根据k获取值，d是默认值，k不存在返回默认 | print(D.get(‘k4’, ‘false’)) | |
| items() | 所有项的键值对形式（非真正意义上的list） | print(D.items()) | |
| keys() | 所有的key列表形式 | print(D.keys()) | |
| values() | 所有的值 | print(D.values()) | |
| setdefault(k[,d]) | 如果key不存在，则创建，如果存在，则返回已存在的值且不修改，类似get（） | print(D.setdefault(‘k4’, ‘v4’)) print(D) | |
| update([E, ]**F) | None | 把字典E的键/值对更新(添加）到dict里（key值相同更新，不同则添加） | F.update(D) print(F) |
三，元祖（tuple)
注意：单元组元素带逗号 t=(1,)
元组的索引，切片，长度，循环，包含以上方法使用同列表一致
元组是有序的不可变的元素集合 。
元组与列表几乎一样，元组使用小括号，列表使用方括号。
但列表可以修改（追加，移除，删除），元组不能修改!
元组是不可变对象，如果需要改变，转化成列表即可元组中只有 count 和 index 方法，方便查找元组中的数据
循环：for
| 方法名 | 返回值 | 含义 | 案例 |
|---|---|---|---|
| count(value) | int | 子元素个数,同列表 | print(T.count(“a”)) |
| index(value, [start, [stop]]) | int | 子元素位置 同列表 | print(T.index(“b”)) |
四，集合（set）
s=set()------空集合定义
集合自动去重
集合变量初始化：元素类型同列表，元素可以使用任何数据类型
一个包含唯一元素的不可变和无序的集合数据类型。
集合的一个用途是快速删除列表中的重复项。
集合中的元素是不可变的类型
集合使用大括号{ }。
同数学上的集合类似，也有交集、并集、子集的数学运算
——特性——
-
唯一性：集合中的元素具有唯一性，不存在两个相同的元素
无序性：集合中的元素是无序的，所以没有存在索引
可变性：集合是可变对象
添加：add() uodate()
删除：remove() pop() discard()
交集：两个set的共同的部分 使用 s1 & s2
并集：由所有属于set A 或属于set B 的元素所组成的 set ,叫做AB的并集 使用 s1 | s2
补集：属于前set，不属于后面set的元素组成的set 使用 s1 - s2
去重：集合自动去重
| 数学符号 | python运算符 | 含义 | 定义 |
|---|---|---|---|
| ∩ | & | 交集 | 一般地,由所有属于A且属于B的元素所组成的集合叫做AB的交集. |
| ∪ | | | 并集 | 一般地,由所有属于集合A或属于集合B的元素所组成的集合,叫做AB的并集 |
| -或\ | - | 相对补集/差集 | A-B，取在A集合但不在B集合的项 |
| ^ | 对称差集/反交集 | A^B，取只在A集合和只在B集合的项，去掉两者交集项 |
功能表
| 方法名 | 返回值 | 含义 | 案例 |
|---|---|---|---|
| add() | set | 增加 | S.add(11) print(S) |
| clear() | set | 清空成为空集合 | S.clear() print(S) |
| copy() | set | 复制 | S1 = S.copy() print(S1) |
| difference() | set | 找出S1中有的，但S2中不存在的集合并赋值给新的变量 | S3 = S1.difference(S2) |
| difference_update() | set | 找出s1中有的，但s2中不存在的集合 ，更新自身 | S1.difference_update(S2) |
| discard() | None | 在集合中移除指定元素，不存在不报错 | S.discard(5) print(S) |
| remove() | None | 在集合中移除指定元素，不存在会报错 | S.remove(6) print(S) |
| intersection() | set | 取s1、s2集合的交集并赋值给新的变量 | s3 = s1.intersection(s2) |
| intersection_update() | set | 取s1、s2集合的交集,更新自身 | s1.intersection_update(s2) |
| isdisjoint() | bool | 判断s1、s2集合是否无交集，有False；无True | ret = s1.isdisjoint(s2) |
| issubset() | bool | 判断s1是否是s2的子集，是 True；否False | ret = s1.issubset(s2) |
| issuperset() | bool | 判断s1是否是s2的父集，是 True；否False | ret = s1.issuperset(s2) |
| pop() | set | 随机删除集合中元素 | a = S.pop() print(a) print(S) |
| symmetric_difference() | set | 把s1存在但s2不存在的和s2存在但s1不存在的元素组成一个新的集合s3 | s3 = s1.symmetric_difference(s2) |
| symmetric_difference_update() | set | 把s1存在但s2不存在的和s2存在但s1不存在的元素组成一个新的集合并更新给s1 | s1.symmetric_difference_update(s2) |
| union() | set | 取s1和s2的并集 | s3 = s1.union(s2) |
| update() | set | 同上，更新为s1 | s1.update(s2) |
类型三
1.运算符：
算术运算符：+，-，*，/，%（取余），**（幂），//（整除）
比较运算符：==，!=，>，<，>=，<=
赋值运算符：=，+=，-=，*=，/=，%=， **=，//=
逻辑运算符：and(与)，or（或），not（非）
成员运算符：in，not in
2.嵌套：
T=(11, 12, [ 'wold', {'k1': 'dd', 'k2': 's'} ] )
print(T[2][1]['k1']) #类型为tuple 输出为dd
3.列表 元祖 字典 set 特点总结：
a. 列表list：有序，可修改，允许重复的集合
b. 元祖tuple：有序，不可修改，允许重复的集合 （元素是可变烈性的元素，可以修改元素内部）
c. 字典dict：无序，可修改，允许重复的集合
d. set：无序，不可变，不允许重复的集合（元素不能是列表，字典等类型）
4.字符串总结：
1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。两种让\不发生转义的方法
a:print（r‘Ru\nood')
b:print（‘Ru\nood’)
2、字符串可以用+运算符连接在一起（该方法效率比较低，不建议使用），用*运算符重复。
3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
4、Python中的字符串中字符不能改变。
5、print(l[::2]):第三个参数表示步长step
6.字符串的转义：
* ： print("=" * 30) 输出30个等号
\n： 换行
\t： 水平制表符
\b： 退格
\r： 回车，当前位置移到本行开头
\\： 代表反斜杠 \
'： 代表一个单引号，同样的 “ ? 等符号也可以这么输出
\0： 代表一个空字符
\a： 系统提示音如果去掉字符串的转义，只需要在字符串前面加上 rr’abc\tabc’
7.字符串的格式化：
format (python特有的) 方法 ”{}-{}-{}“.format()
s = "name %s, age %d" % ("符华", 50000) # %方法 必须一一对应否则会报错
print '{:.2f}'.format(321.33345) #321.33 保留两位小数
s = "name {}, age {},".format("Bronya", 17) #无序一一对应
s = "name {0}, age {1}".format("Bronya", 17) #无序一一对应
L=["Bronya", 17]
s = "name {0}, age {1}".format(*L) # name Bronya, age 17
s = "name {name}, age {age}".format(age=17, name=Bronya) #已和下标没有太大关系
| 格式 | 描述 | 例子 | 格式 | 描述 |
|---|---|---|---|---|
| %% | 百分号标记 | “%d-%d-%d” %() | %e | 浮点数字(科学计数法) |
| %c | 字符及其ASCII码 | %E | 浮点数字(科学计数法，用E代替e) | |
| %s | 字符串 | %f | 浮点数字(用小数点符号) | |
| %d | 有符号整数(十进制) | %g | 浮点数字(根据值的大小采用%e或%f) | |
| %u | 无符号整数(十进制) | %G | 浮点数字(类似于%g) | |
| %o | 无符号整数(八进制) | %p | 指针(用十六进制打印值的内存地址) | |
| %x | 无符号整数(十六进制) | %n | 存储输出字符的数量放进参数列表的下一个变量中 | |
| %X | 无符号整数(十六进制大写字符) |
格式化得到的结果都是字符串，通过把位置预先留出来，后期再往其中填入内容可以让输出内容更加整洁美观，而又具有良好的可读性，同时让代码更简洁精练字符串的转义可以方便我们表示我们不太方便表示的字符，同时转义有些情况下又会带来麻烦，特别是在表示路径的时候，这种情况下可以在字符串前面加上 r 来去掉字符串的转义
类型四
1.字符串编码：
编码（encode） unicode编为指定的其他编码
解码（decode） 其他编码转成unicode
s="有基佬开我裤链“
utf8 = s.encode("utf-8")
printf(utf8)
utf8_gbk = utf8.decode("gbk")
print(utf8_gbk)
2.深浅复制：
字符串 数字 赋值 深浅拷贝无意义都是内存
浅复制：在内存里只额外创建了第一层
方法 copy
深复制：只是创建一个变量 ，该变量复制原来的内存地址但与原来互不影响
方法 deepcopy
3.bytes和bytearray：
bytes
基本用法：
print(type(b"fffff")) #类型为 bytes不为str
b=bytes("守望先锋", encoding="utf-8")
bytearray
s="守望先锋“
b=bytearray(s.encode("utf-8")) #类型为 bytearray
二，控制流程
1.条件判断
语法结构：
if 判断语句1:
执行语句1
elif 判断语句2:
执行语句2…
else:
执行语句
2.三目运算
if b>5:
print(Ture)
else:
print(False)
三目运算
print(Ture) if b> 5 else print(False) #只能用在if else 的简单判断情况
3.条件循环
while：条件满足才执行语句 注意不要死循环了
break和else：break终止循环 else循环全部结束后执行，并且要求循环不是被break掉的
continue：跳出当前循环继续下一次循环
注意要点：
-
循环可以被终止： 通过break终止循环 通过continue跳过当此循环
else的执行条件： 只有在循环不是被break终止的情况下才会执行else中的内容
4.迭代循环
for迭代：
语法规则： for x in y: #x为元素 Y必须为可迭代对象
循环体 注意缩进
判断是否为可迭代对象：能不能for 有iter对象
range：与切片类似 有 头 尾 步长+
注意要点：
-
for 后面需要接上可迭代对象
for会依次取出可迭代对象中的元素
continue的用法:
continue和break类似，但是continue不会终止循环，而是结束本次循环，跳到下次循环
三，函数基础和函数参数
函数基础
函数定义
def 函数名(参数)：函数头
pass 函数体（表达式）
return 返回值
函数名命名规则： 字母、数字和下划线组成，和变量命名规则一致return 后面可以返回任意表达式，但不能是赋值语句
函数参数
1.必须参数
def func(x):
print(x)
func(1)
x称为形参(必须参数) 1称为实参（位置参数）
实参与形参一一对应
2.默认参数
def func(x, y=None):
print(x)
print(y)
func(1)
func(1, 2)
调用的时候如果没有传入实参，就用默认值，有实参就覆盖，必须写在必须参数后面
3.关键字参数
def fun(a, b, c)
print(a)
print(b)
print(c)
fun(b=2, c=3, a=1) #1 2 3
函数的参数会按照关键字去找对应的值
4.动态函数
def func(*args, **kwargs):
print(args)
print(kwargs)
func(1, 2, 3, a=4, b=5, c=6)
func(*(1, 2, 3), **{'a': 4, 'b': 5, 'c': 6})
*args： 传入的位置参数都会被接受生成一个元组
**kwargs： 传入的关键字参数都会被接受生成一个字典
拓展：为动态参数传入 列表（使用*） 字典（使用**）
常见内置参数
1.简单内置函数
内置对象查看： dir(builtins)
常见函数：
-
len 求长度 reversed 反向
min 求最小值 sum 求和
max 求最大值 sorted 排序
进制转换函数：
-
bin( ) 转换为二进制
oct( ) 转换为八进制
hex( ) 转换为十六进制
ord( ) 字符转ASCII码
chr( ) ASCII码转字符
2.高级内置函数
enumerate 返回一个可以枚举(遍历)的对象
eval： 取出字符串中的内容将字符串str当成有效的表达式来求指并返回计算结果（识别是表达式，并有返回值）
exec： 执行字符串没有返回值
filter：（函数，可迭代对象） 过滤器，取出每一个可迭代对象去执行函数，符合条件的留下不符合的删除
map：取出每一个可迭代对象去执行函数，并将结果进行处理作为列表输出
zip： 将对象逐一配对，并将结果进行处理然后输出
![TestLink导出用例转换工具(XML2Excel)[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)