数据类型（字符串、元组、列表）总汇——python

变量类型

严格意义上讲python只有一个类型
标准数据类型有6种

1. 数字 number
2. 字符串类型
3. 元组 tuple
4. 列表
5. 字典
6. 集合

None类型

表示没有，通常用来占位
比如函数返回，当不知道返回什么时用来返回一个空 return None

数字类型number

  python中的数字没有大小限值
  ***常见数字分类***
  整数、浮点数、科学计数法、复数 

1、 整数：没有小数部分 ，包含正数、负数、0、以及R进制数
二进制数

#二进制以0b开头表示二进制数
a=0b11111
print(a)
#print()语句打印出来的结果为十进制数

八进制数

#以0o开头
a=0o71
print(a)#仍为十进制

十六进制数

b=0x11
print(b)

进制之间的转换如下图（简单了解）

2、浮点数（即通常意义上的小数）
常见格式：3.1415926
科学计数法：AeB 注意B必须为整数

a=313
b=3.13e2
print(a==b)

3、复数
（complex和数学定义上一样，若不明白可咨询您的贴身小伙伴百度君）
R=X+jB 实部和虚部组成

print(3+4j)
#输出结果 3+4j

4、布尔值
布尔值就是用来表示真假的值，就两个值
True和False (注意大小写)
在python中布尔值可以当数字使用，True=1，False=0.
如果数字当作布尔值使用0=False,其余全当作True.

#布尔值当作数字使用
age=18+True
print(age)
#数字也可以当布尔值使用

字符串

定义：一系列字符组成的连续序列，它用于表示文本类型的数据，比如人的姓名、家庭地址等等。（表示文字信息）
表示：在python中，使用一对单引号或双引号来包含字符串类型的数据，且单引号或双引号必须成对出现，并且两者是等价的。
注意：如果字符串中出现了单引号则该字符串必须用双引号包含，反之亦然！

print("this's mine")

倘若同时出现单或双引号此时要用三引号包含（成对的）。
引入一对三引号有特殊功能。
1、如下，用来表示一段包含换行标记的字符串数据

#可以换行输入
print(''' this is my love
,..no is me''')
#这姓结果：

this is my love
,…no is me

在交互模式下如下：

‘’’ this is my love
,…no is me’’’
结果：’ this is my love\n,…no is me’
多了一个转义字符“\n”表示此处进行了换行
2、三引号还可以实现多行注释的作用

'''gs akc liachali 对此就进行了注释'''
#在python中单行注释为 #

字符串的“+”，“*”运算（连接、复制）

#连接
print("hello " + "world")
#复制
print("hello" *3)
print('''hello
'''*3)#会把该字符串复制3次三行输出因为三丹特殊功能

（小提示：在文件模式下字符串结果不加引号输出，交互模式下带有引号输出）
获取字符串长度
返回字符串长度一般用len()函数(含参)

name="Faye w"
print(len(name))

python中sep和end的区别
end: 默认换行，表示两个字符串最后以什么结尾。因为python中每一个print后都会自动换行，若想让其在一行输出，在print中内置end

for i in range(5):
	print(i,end=" ")
#结果：0 1 2 3 4
for i in range(5):
	print(i,end=",")
#结果：0，1，2，3，4

sep: 默认空格，表示两个字符串之间用什么分割

print("hello","world",sep=".")

转义字符
定义：用一个特色方法表示出一系列不方便表示的内容。比如：回车、换行等等

借助反斜杠(“\”），一旦字符串中出现反斜杠，则反斜杠后面一个或几个字符表示已经不是原来的意思了，进行了转义。

在字符串中一旦出现反斜杠就要加倍小心，可能有转义字符出现

不同系统对于换行操作有不同的表示（唯一的一个特例其它基本上对系统无要求）
windows:\n
linux:\r\n

print("hello\nworld")

若想输出字符串中含反斜杠且不表示转义
比如表示 C:\User\Augsnano (表示一个路径)
（两个\表示转义反斜杠）

#print(" C:\User\Augsnano")
#程序将要报错，因为\U表示一个转义，但是后面又有字符所以不能进行解释。此时要用到转义
print(" C:\\User\\Augsnano")
#**两个\\表示转义反斜杠**

所有的转义字符
(在行尾时) 续行符
(续行符可以将一行程序分成两行，但如果非要写在一行时请用“；”（分号）隔开)
\ 反斜杠符号
’ 单引号
" 双引号
（转义单双引号的可以用单双引号嵌套的方式，即可不使用转义字符也可以实现）
\a 响铃
\b 退格*(Backspace)*
\e 转义
\000 空
\n 换行（windows系统）
\v 纵向制表符
\t 横向制表符
\r 回车
\f 换页
\odd 八进制数，dd代表的字符，例如：\o12代表换行
\xhh 十六进制数，hh代表的字符，例如：\x0a代表换行
\other 其它的字符以普通格式输出
单个斜杠的用途
在python里，单个反斜杠表示此行未结束，出于美观，需要下一行继续
str格式化
：把字符串按照一定格式进行打印或填充
格式化的分类
1、字符串的传统格式化方法
使用%进行格式化——（%-百分号也叫占位符）
： %c 格式化字符及其ASCII码
%s 格式化字符串
%d 格式化整数
%u 格式化无符号整型
%o 格式化无符号八进制数
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数（大写）
%f 格式化浮点数字，可指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同%e，用科学计数法格式化浮点数
%g %f和%e的简写
%G %F 和 %E 的简写
%p 用十六进制数格式化变量的地址

str="Faye w %s"
print(str)
#结果:Faye w %s （此处的%占位置，s即所占空）
str="Faye w %s"
print(str%'wang')
#结果：Faye w wang

如下：当出现%s说明后面可以用字符串替代

print('I Love %s'%"wang")

当被格式化的信息多于一个时，用括号括起来即可
(%.nf)----表示保留n位

xiao="今年%d岁"
print(xiao%19)
#当被格式化的信息多于一个时，用括号括起来即可
wid="我的体重为%fKG,%fM身高"
print(wid%(65.80,1.80))

2、format格式化
格式化函数功能
将字符串进行格式化操作，字符串中的”{}“ 为占位符，将以次被括号中的参数替代。如下计算圆面积程序

pi=3.14
r=eval(input("请输入半径："))
s=pi*r**2
print("您输入的半径为{}面积为{}".format(r,s))
#使用format()时注意加上分隔符

format()要点介绍
1、”{}“中，若是无数字则按默认顺序输出，若有数字则按数字顺序输出（注意下标从0开始）
2、保留位数在“{}”中添加**“:.nf”** 即可保留n位。
3、“:k.nf” 保留n位且占k位，若k前无任何符号默认右对齐
若 “:<k.nf” 左对齐
若 “:^k.nf” 居中对齐
4、若**"f"换成“e“则按科学计数法输出
5、冒号”：“之前的数即为第一条所述
6、本人为python 3.7所以在保留n位时进行的四舍五入**（有待商榷）
介绍四舍六入五成双
一般在函数中round()函数一般遵顼该原则
当被修约值为5时如果他前面的数为偶数且被修约数后面没有数时则直接舍弃
当被修约值为5时如果前面数为奇数时则进位
当被修约值为5时如果前面数为偶数且被修约数后面还有数时则进位
简介round(x,y)

round(x,y)
#x为要处理的数 y为要保留的位数

7、前述知格式化函数可以占k位以及对齐方式，当在k之前（准确讲冒号后）加上某个数字可以对剩余的进行补位（填充），若想用其它符号补位要在k和该符号之间加上对齐方式。（只能是一个字符，不指定默认为空格填充）
8、+表示正数前显示正，-表示负数前显示负
9、b、d、o、x表示二、十、八、十六进制
10、使用大括号转义{}

k="format使用{}来占位"
print(k.format({}))

小案例：
通过字典设置参数，需要解包（解包操作后面会讲到）
使用命名参数

s="大家好我是{name},你是{name1}."
s_dict={"name":"小王","name1":"小李"}
#加上两个**表示解包操作，后面会提到
print(s.format(**s_dict))

str内置函数
help(str)可查看其内置函数方法
1、str.count()——查找元素出现的次数

l="sdhcjjk"
print(l.count('j'))

2、str.find(obj,key)——查找字符串中是否包含一个字串（查找其位置，若无 返回值为-1）
obj——查找的元素
key——要开始查找的起始位置（无时默认为从0开始）

s="大家好我是"
print(s.find("我是"))

3、str.index(obj,key)——查找某个元素第一个匹配项的位置

s="hghfhhc"
print(s.find("h"))
#返回值为0

（find index 均为从左向右查询，若想从右向左rfind、rindex）
4、判断类函数（此函数类型特点一般都是用is开头）

1. isalpha——判断是否是字母
   需要注意：此函数默认的前提是至少包含一个字符，如果没有，返回False.汉字被认为alpha，所以，此函数不能作为区分英语字母还是汉字的标识，区分中英文请使用unicode码
   2、 isdigit isnumeric isdecimal 三个判断数字的函数
   真要判断数字，不建议使用
   （谨慎使用，防止被坑，特别是在爬虫阶段，判断数字（正则表达式））
   digit：
   True：Unicode数字、全角数字（双字节）、罗马数字、byte数字
   False：汉字数字
   Error：无
   isdecimal:
   True：Unicode数字、全角数字（双字节）
   False：罗马数字、汉字数字
   Error：byte数字
   isnumeric：
   True：Unicode数字、全角数字（双字节）、罗马数字、byte数字、汉字数字
   False：无
   Error：byte数字

chin="一二三四"
print(chin.isdigit())
print(chin. isdecimal())
print(chin.isnumeric())

3、istitle()——判断首字母是否是大写
4、ispace()——检查字符串中的字符都是空格
5、islower——检查所有字符是否是小写
6、isupper——检查所有字符是否是大写（汉字字符串无大小写概念）
5、内容判断类
1、startswith/endswith——是否以XXX开头或结尾
需要三个参数
–suffix：被检查的字符串，必须有
–start：范围的开始（可选）
–end：范围的结束（可选）

s="hghfhhc"
print(s.startswith("h"))

6、操作类函数
1、–format()函数
2、–strip()函数，这个函数主要作用是删除字符串两边的空格，其实这个函数允许你去定义删除字符串两边的那个字符，只不过如果不指定默认是空格。同样还有lstrip 和rstrip，此处分别表示左边右边，即删除字符串左边或右边制定字符，默认空格。需要注意的是，此处的删除不是删除一个，是指从头开始符合条件的连续字符串。
（删除的是符合条件的连续字符串）

c="dddaads love wang fei "
print(c.strip('d'))
#结果aads love wang fei

（是否能知道空格是否删除了）

c="dddaads love wang fei "
print(c.strip())
#对于上述程序返回结果并不能看出来是否删除了空格
#但如果想看出来
print(c.strip(),end="---")
#结果：dddaads love wang fei--- 
#fei后直接和--相连说明删除了空格

3、–join ——这个函数主要对字符串进行拼接。它需要一个可以迭代的内容作为参数。功能是把可迭代的字符串拼接在一起，中间使用调用字符串作为分隔符。

s1="$"
s2='@'
ss=["liu","da","ma"]#可以迭代的参数
print(s1.join(ss))
print(s2.join(ss))

上述对字符串进行了基本说明

元组（tuple）

定义：一系列数据的有序集合，一旦初始化就不能再修改
注意：一旦初始化就不能在修改
引入之前先分析一个案例
案列：计算平均分

score=(99,98,74,75,45,65)
sum=0
for i in range(6):
    sum=sum+score[i]
avg=sum/6
print(avg)

从上述可以得出元组的几个要点

1. 在python中使用圆括号（) 表示元组，元素用逗号隔开。
2. 定义一个元组要与赋值语句结合使用
3. 使用for语句可以实现对元组的循环遍历
4. 对元素进行遍历也可以使用索引进行提取元素。（索引从0开始）如：score[1]=98。即：元组名[元素序号]
5. 上述出现了一个内置函数range()函数见下图：
   
   返回值机制
   如果我们希望执行完函数体之后能够返回一个执行结果，此时需要使用返回值机制，在函数中使用return语句，即可将函数中的执行结果返回给调用者
   （在此引入目的：当返回结果不止一个时，元组开始起作用）

score=(99,98,74,75,45,65)
sum=0
for i in range(6):
    sum=sum+score[i]

avg=sum/6
print(avg)
def getmaxmin():
    n=0
    m=100#设置0和100是因为以分数为案例百分制的
    for i in score:
        if i>n:
            n=i
        if i<m:
            m=i
    return (n,m)
max,min=getmaxmin()
print("最大值{},最小值{}".format(max,min))

元组的其它方法及内置函数
1、遍历元组的两种：for i in 元组名
for i in range(n)
2、可以创建一个空元组 tuple=()
3、元组虽然一旦初始化就不能修改，但是可以将元组进行连接、复制操作
方法和字符串一样“+”即连接、“*”即复制

t1=(1,2,3)
t2=("as","s")
print(t1+t2)

4、删除元组，格式：del 元组名
5、len()——返回元素个数。
6、元素 in 元组——查看是否在该元组内
7、元组的索引、截取
从前知索引从0开始，若想反向索引从（-1）开始
截取元素：元组名[n:k] ——表示从序号n开始截取直到序号（k-1)结束

t1=(1,2,3,5,6,7,8,9,8)
print(t1[2:])

8、任意无符号的对象以逗号隔开，默认为元组
9、元组内置函数如下
1.cmp(t1,t2)——比较两个元组元组元素（python3.X已经没有cmp函数，不做要求）
2.max(tuple) min(tuple)——返回元组的最值
3、将列表转换为元组——tuple(list)

k=[1,2,5]
print(tuple(k))

列表 （List）

定义：列表是一种有序的集合，可以随时添加和删除其中的元素
案列：学习之前先分析一个小案例，如下：
引入排序方法：选择排序法——通过构造循环结构程序，第一次将最大的数放在首位，第二次将第二大的数放在列表第二位，以此类推直到全部排好为止。
引入列表小要点
列表用“[]”表示，元素用逗号隔开，与元组不同的是列表可以修改
例子：将元素按从小到大输出

t1=[1,2,3,5,6,7,8,9]
#返回列表长度
k=len(t1)
for i in range(k):
    for j in range(i+1,k):
        if t1[i]<t1[j]:
            t1[i],t1[j]=t1[j],t1[i]
print(t1)

列表各个方法以及内置函数等
1、无任何数据的列表为空列表
2、列表是可以修改其元素的，append()方法——在列表末尾添加新的对象（无返回值（外置,这里的外置可以见下列代码理解））
格式：list.append(obj)

s=[]
s.append("ninnhao")
print(s)

3、count()——和字符串用途一样（内置）

s=["aas",1,3,3,5,6]
#内置
print(s.count(3))

4、extend()——用于在列表末尾一次性追加另一个序列中的多个值（外置）
格式：list.extend()

s=[1,2,3,4]
#字符串
k="hight"
#元组
width=(77,88,99)
#列表
alist=["您好"]
s.extend(k)
print(s)
#与字符串序列进行连接时，字符串会被如下操作
#[1, 2, 3, 4, 'h', 'i', 'g', 'h', 't']
s.extend(width)
print(s)
#[1, 2, 3, 4, 'h', 'i', 'g', 'h', 't', 77, 88, 99]
s.extend(alist)
print(s)
#[1, 2, 3, 4, 'h', 'i', 'g', 'h', 't', 77, 88, 99, '您好']

5、index()——查找列表中某个值第一个匹配项的索引位置（即使有重复的，也只能找到第一个的索引位置）（内置）
格式：list.index(obj,start,end) 对象 起始位置 结束位置
6、insert()——用于将指定元素插入指定位置（外置）
格式：list.insert(index,obj) (索引位置，插入的对象)
7、pop()——用于移除列表中的一个元素，并返回移除元素的值，无特殊说明时，默认移除的元素为最后一个。（内置）
要移除的索引值不能超过列表的总长度
格式：list.pop(index) 参数为：要移除的索引号，无，默认移除最后一个

seq=[1,2,3,5,3,6]
print(seq.pop())

8、remove()——移除列表中某个值的第一个匹配项，无返回值（外置）
格式：list.remove(obj) 参数：要移除的对象
9、reverse()——用于反向列表元素（外置）
格式：list.reverse() 无参

seq=[1,8,9]
seq.reverse()
print(seq)

10、sort()——对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数（外置）
格式：list.sort(cmp=None,key=None,reverse=False)
–reverse 排序规则，reverse=True时，降序。reverse=False时，升序。一般默认为升序

seq2=[12,34,44,54,65,66]
seq2.sort()#里面为空默认为升序排列
print(seq2)

11、cmp()——比较
len(list)——返回长度
max()/min()——返回最值
list(tuple)——将元组转换为列表
12、列表的迭代与截取与元组操作以及循环遍历相同（可参考元组）
13、列表也可以进行复制和连接（与元组同）
14、元素 in list ——查看是否在该列表中
15、del list[] 或del list ——删除列表中的元素或整个列表
（以上为列表的各个操作方法，关于List的其它方法可以使用help(list)获取）

字典(dict)

定义：通过关键字与数据产生映射关系的数据结构，具有极快的查找速度
–字典是另一种可变容器模型，且可存储任意类型对象
字典的构成：字典由键值对构成，键和值之间用冒号隔开，键值对之间用逗号隔开，整个字典用“{}”包含。
要点：1、键一般是唯一的，如果重复，最后一个键值对会替换前面的，值不需要唯一。

dict={"name":"xiaoming","li":"ss","name":11}
print(dict)

2、特性值可以取任何类型，但键必须是不可变的（键只能从：字符串、数字、元组充当）
3、访问通过键访问值，格式：dict[键]
4、也可定义空字典

dict={}
dict["name"]=2
print(dict)

5、修改字典
向字典添加新内容的方法是添加新的键值对，修改或删除
格式：dict[键]=要修改的值
格式：dict[添加的新建]=值

dict={'a':2,'c':1,'d':6}
dict['b']="加油"
dict['d']="6+6"
print(dict)

6、删除字典元素，即能删除单一的也能对字典进行清空
格式:del dict 或del dict[键]

dict={"name":"xiaoming","li":"ss","name":11}
del dict["name"]
print(dict)

清空字典所有条目，但不代表字典没有了
格式：dict.clear()——(外置)
字典内置函数与方法
1、cmp()、len()、[type()返回输入变量类型]、【str(dict)——将值转化为适于阅读的形式，便于打印和输出】

dict={'a':2,'c':1,'d':6}
print(str(dict))

2、copy()——返回一个字典的浅复制（有返回值，内置）
格式：dict.copy() 无参
3、fromkeys()方法——用于创建一个新字典，以序列seq作为键，value做为键对应的值/
格式：dict.fromkeys(seq,value)
seq 字典键值列表（即为一个序列，用于产生键）
value 可选参数，设置键序列值
返回一个新字典，有返回值（内置）

seq=("a","b","c")
dict={}#创建一个新字典，应先定义一个字典
dict1=dict.fromkeys(seq,10)
print(dict1)

4、get()方法——返回指定键的值，如果值不在字典里返回默认的值（内置）
格式：dict.get(key,default=None)
default——如果不存在，返回该默认值

seq={'a':2,'c':1,'d':6}
d=seq.get("a",None)
print(d)

5、has_key()方法——判断键是否在字典中，在返回True不在False。但是在python3中已经没有此方法了，被__contains__(key)替代（内置）

se={'qw':14,'qq':'ss','sqw':'dggdg'}
print(se.__contains__('qw'))
#检查键是否在字典中，有返回True，若没有返回False,
#注意__contains__前后为两个下划线

6、items()方法——以列表返回可遍历的（键值）元组数组
格式：dict.items()——（内置，有返回值）
items方法把字典键值组成一个元组，并把这写元组放在列表中返回

dict={'a':2,'c':1,'d':6}
print(dict.items())
#返回值：dict_items([('a', 2), ('c', 1), ('d', 6)])
#循环遍历字典列表格式
for i,j in dict.items():
    print(i,j)

7、keys()——以列表形式返回字典中的键
格式：dict.keys(）
values()方法，以列表返回字典所有的值
格式：dict.values()
8、setdefault()方法与get(）方法同，但不一样的是setdefault()方法会改变字典，会把查找不到的键插入字典中，默认值为新插入的值。

se={'qw':14,'qq':'ss','sqw':'dggdg'}
print(se.setdefault('q',None))
print(se.setdefault('c','taoabo'))
print(se)
'''
返回结果如下
None
taoabo
{'qw': 14, 'qq': 'ss', 'sqw': 'dggdg', 'q': None, 'c': 'taoabo'}'''

9、update()方法——进行字典的更新
格式:dict.update(dict1)——把字典dict1添加到字典dict里
10、pop（）方法——删除字典给定的键值，并返回
格式：dict.pop(key,default)

se={'qw':14,'qq':'ss','sqw':'dggdg'}
print(se.pop ('qq',None))#删除字典给定键key及对应值，返回被删除的值

11、popitem()——返回并删除字典中的最后一对键和值

dict={'a':2,'c':1,'d':6}
print(dict.popitem())#返回一个（key,value）的形式。

（以上对字典进行了简要说明，更多操作可问你的小伙伴某度君）

集合

集合的一些常用运算如下

list = [1, 1, 3, 2, 3]
s = set(list)

print(s)
# s.add([2,3]) 错误，add函数只能增加与原集合相同类型的元素
s.add(4)
print(s)
  
s.update([3, 5, 6])
# s.update(5) 错误，update更新集合时传入的是一个可迭代对象
print(s)
  
o = s.copy() # 用于集合复制,创建新集合
oo = s
print(o)
print(cc)
# 类似于list中copy方法
print(oo is o)
  
ss = {1, 2, 3, 9}
jiao = s.difference(ss) # 求差集
print(jiao)
  
nion = s.union(ss) # 求并集
print(nion)
  
intersection = s.intersection(ss) # 求交集
print(intersection)