一、数字类型

1.整型int:用来记录年龄、等级、号码等

int()可以接收数字和纯数字组成的字符串参数,不能接收浮点数的字符串.

当参数为浮点数时,函数会返回参数的整数部分.当参数是整数字符串时,函数将其转换为整型

定义一个整型变量：

a=27

int

2.浮点型float：用来记录身高、体重、工资等

定义一个浮点型变量：

price=11.22

float

进制转换：

十进制  ——>二进制  bin(27)   [反向为int("0b11011",2)]

十进制  ——>八进制 och(27)   [反向为int("0o33",8)]

十进制  ——>十六进制  hex(27)  [反向为int("0x1b",16)]

二、字符串str：用来记录描述性质状态，如名字、性别等

用引号('',"",'''''')将内容包含起来赋给变量名，就可以定义一个字符串变量。

只有在全部数据为字符串时，用eval

使用引号将内容包含起来赋给变量名，就可以定义一个字符串变量。定义这两个变量时，实际调用了 str() 函数。

name='lalal'当字符串内有引号时，定义的引号需要不能和其相同：

str3= "hello,I'm lily."字符串类型可以用运算符进行简单的拼接：

str1= "hello"str2= "world!"res= str1+str2print(res) #hello world!

print(res*3) #hello world! hello world! hello world!

字符串类型之间也可以比较大小：

str1= "hello"str2= "world!"

print(str1>str2) #False,根据ASCII码得来. A

字符串类型并不能和其他数据类型进行拼接和运算

str

需要即时掌握的操作1.strl[0] 按索引取值2.strl[1:3:2] 切片(顾头不顾尾，步长)3.len 长度(统计的是字符个数)4.in/not in成员运算 (返回布尔值)5.strip,lstrip,rstrip 移除空白6.split，rsplit 切分.切出来的是列表7.for i in listl 循环遍历

str1 = "lalal,27,hello world!"list1=[#str1[0:9:3], # la2 间隔两个字符切片(步长指定为2,默认为1)

#str1[:], # lalal,27,hello world! 起始位置和结束位置默认为0,可以获得一个同样的字符串

#str1[::-1], # !dlrow olleh,72,lalal 返回一个倒序字符串

#str1[-3:], # ld! 返回后三个字符

#str1[-1:-5:-1], # !dlr 起始位置都可以是负值,但切片的方向要和步长一致

#len(str1), # 21 返回str1的长度(字符个数),如果len()的参数是列表、元组,则返回元素个数

#"12" in str1, # False 成员运算,返回布尔值

#str1.strip(), # lalal,27,hello world! 移除str1两端的指定字符,默认为空格 返回一个新的字符串

#str1.split(",", 2), # ['lalal', '27', 'hello world!'] 此函数接收两个参数:切分字符和个数,返回一个列表

"0".join(str1.split(",", 2)) #lalal0270hello world! 将切分后的列表元素以指定的字符拼接,原理是字符串拼接+迭代#]for i inlist1:print(i)

需要即时掌握的操作

需要优先掌握的操作1.lower 将str1内的英文字符转换为大写2.upper 将str1内的英文字符转换为小写3.startswith 判断str1是否以"xx"开头,并返回布尔值4.endswith 判断str1是否以"xx"结尾5.fomat 格式化输出三种用法(与%：%需要一一对应，相当于第一种用法，数目不匹配报错。)6.replace 替换7.join 拼接，相当于for循环，可迭代的对象必须都是字符串8.isdigit 判断字符是否为"数字"，可以判断bytes和unicode类型9.isinstance 判断...是否是...类型

str1 = "lalal,27,hello world!"list1=[

str1.lower(),#lalal,27,hello world! 将str1内的英文字符转换为小写并返回一个新字符串

str1.upper(), #LALAL,27,HELLO WORLD! 将str1内的英文字符转换为大写并返回一个新字符串

str1.startswith("12"), #False 判断str1是否以"12"开头,并返回布尔值

str1.endswith("!"), #False 判断str1是否以"!"结尾,并返回布尔值

"la{},27,hel{}lo world!".format("3", "T"), #la3,27,helTlo world! 格式化输出:按顺序输出

"la{1},27,he{0}world!".format("3", "T"), #laT,27,he3world! 格式化输出:指定位置

"la{x},27,he{y}world!".format(x="3", y="T"), #la3,27,heTworld 格式化输出:指定关键字!

str1.replace("27", "dz", 1), #lalal,27,hello world! replace接收三个参数:原字符,替换字符,替换字数

str1.isdigit(), #False 判断str1是否是纯数字字符,返回布尔值

]for i inlist1:print(i)

需要优先掌握的操作

需要了解的方法1.count2.find,rfind3.index,rindex4.center,ljust,rjust,zfill 居中，左，右，5.captalize 首字母大写6.swapcase7.title 全大写

str1 = "LalAl,27,heLlo World!"list1=[

str1.count("l"), #4 返回srt1内指定字符的个数,不指定字符则统计整个字符串的字符数

str1.find("27"), #6 返回指定字符在str1中的索引,如果不存在则返回-1。 rfind()从右向左寻找

str1.index("La"), #0 返回指定字符在str1中的索引,如果不存在则报错。 rindex()从右向左寻找

str1.center(30, "_"), #__LalAl,27,heLlo World! ___

#返回一个原字符串居中,并使用指定单位字符

#填充至指定长度的新字符串。默认填充字符为一个空格。

#如果指定的长度小于原字符串的长度则返回原字符串。

#类似调整格式的方法还有 左对齐:ljust() 右对齐:rjust() 用0填充:zfill()

str1.capitalize(), #Lalal,27,hello world!首字母大写

str1.swapcase(), #Lalal,27,hello world!大小写互换

str1.title() #Lalal,27,Hello World! 返回英文单词首字母大写的字符串

]for i inlist1:print(i)

需要了解的方法

is数字1.isdigt:判断bytes,unicode类型2.isdecimal:uncicode3.isnumberic:unicode,中文数字,罗马数字4.isalnum5.isalpha6.isidentifier7.islower,isupper8.isspace9.istitle

#is数字系列#在python3中

num1='4' #bytes

num2=u'4' #unicode,python3中无需加u就是unicode

num3='四' #中文数字

num4='Ⅳ' #罗马数字

print(num1,num2,num3,num4) #4 4 四 Ⅳ

#isdigt:bytes,unicode

print(num1.isdigit()) #True

print(num2.isdigit()) #True

print(num3.isdigit()) #False

print(num4.isdigit()) #False

#isdecimal:uncicode#bytes类型无isdecimal方法

print(num2.isdecimal()) #True

print(num3.isdecimal()) #False

print(num4.isdecimal()) #False

#isnumberic:unicode,中文数字,罗马数字#bytes类型无isnumberic方法

print(num2.isnumeric()) #True

print(num3.isnumeric()) #True

print(num4.isnumeric()) #True

#三者不能判断浮点数

num5='4.3'

print(num5.isdigit()) #False

print(num5.isdecimal()) #False

print(num5.isnumeric()) #False

'''总结:

最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景。

如果要判断中文数字或罗马数字,则需要用到isnumeric'''

#is其他

print('===>')

name='egon123'

print(name.isalnum()) #True 字符串由字母或数字组成

print(name.isalpha()) #False 字符串只由字母组成

print(name.isidentifier()) #True

print(name.islower()) #True

print(name.isupper()) #False

print(name.isspace()) #False

print(name.istitle()) #False

is系列

字符串的一些方法,比如按按索引取值、成员运算、切片、返回长度(元素个数)等方法对于列表,字典等数据类型同样适用.

三、列表list：用来记录多个值，用索引对应值，索引反映位置。在[]内以逗号分隔多个任意类型的值

list1=[1,2.1,'lalal',['a','b','c']]print(type(list1)) #

print(list1[0]) #1

print(list1[3][0]) #a

当索引超出列表的长度时，就会报错

list的定义用法

需要优先掌握的操作1.listl[0] 按索引取值2.listl[1:3:2] 切片(顾头不顾尾，步长)3.len 长度(统计的是元素个数)4.in/not in成员运算 (返回布尔值)5.append 追加(如果有一个列表，会将其当作一个元素整个追加)6.insert 插入7.del删除(根据索引删)8.remove 删除(单纯的根据元素名去删)9.pop 删除(若不指定索引，默认取走最后一个，有返回值，为删掉的值)10.for i in listl 遍历列表

l = ['a', 'b', 'c', 'd', 'e']print(l[0], l[0:2:1]) #a ['a', 'b'] 按索引取值、切片(返回子列表)，与字符串切片方法相同

l[2] = "C" #替换索引位置元素

print(l,len(l)) #['a', 'b', 'C', 'd', 'e'] 5 返回列表与元素个数(长度)

print("a" in l) #True in/not in成员运算

l.append("1") #列表末尾追加元素,无返回值

print(l) #['a', 'b', 'c', 'd', 'e', '1']

l.insert(0, 11111) #在指定索引位置插入元素IKN

print(l) #[11111, 'a', 'b', 'c', 'd', 'e']

del l[0] #删除

print(l) #['a', 'b', 'c', 'd', 'e']

l.remove("b") #删除指定元素

print(l) #['a', 'c', 'd', 'e']

l.pop(1) #删除指定索引位置元素，并将删除的元素返回。默认索引为-1

print(l) #['a', 'd', 'e']

for item in l: #遍历列表

print(item) #a d e

需要优先掌握的操作

需要掌握的操作1.count 计数2.extend 追加(如果有一个列表，会将其按元素逐个添加)3.index 索引所在位置，可以指定起始范围，若没有该vaule，报错。4.reverse 倒序5.sort 排序(从小到大)可以跟匿名6.join

l = ['a', 'b', 'c', 'd', 'e']print(l.count("a")) #1 返回列表中包含指定元素的个数

l2= ["!","!"]

l.extend(l2)print(l) #['a', 'b', 'c', 'd', 'e', '!', '!'] 接收一个可迭代对象，将其元素添加到l中，返回None

print(l.extend(12)) #报错

print(l.index('c')) #2 返回指定vaule的索引，可以指定起始范围，若没有该vaule，报错。

l.reverse() #反转列表

print(l) #['e', 'd', 'c', 'b', 'a']

print(l.reverse()) #None

l.sort()#将列表中元素按从小到大顺序排序，若指定reverse=True，则倒序

print(l) #['a', 'b', 'c', 'd', 'e']

需要掌握的操作

1.队列:先进先出

l=[]

l.append('first')

l.append('second')

l.append('third')print(l) #['first', 'second', 'third']

print(l.pop(0)) #first

print(l.pop(0)) #second

#2.堆栈:先进后出#l=[]

l.append('1')

l.append('2')

l.append('3')print(l) #['1', '2', '3']

print(l.pop(-1)) #3

print(l.pop(-1)) #2

队列、堆栈

列表生成式 【i for i in range(10)】 --详情后文讲

四、字典dict：在{ }里，用key：vaule的形式存放多个元素，并用，将元素隔开.

字典的key一定是不可变类型(内部需要做hash)，因为key起到描述作用，一般是字符串型，vaule可以是任意类型。定义字典调用了 dict()方法，dict() 接收可迭代对象(k, v in iterable)和关键字参数：

d = {'name1':'lalal','name2':'ann','name3':'sha'}print(d["name1"]) #lalal

字典没有索引，即无序的。用花括号{ } 可以定义一个字典，字典的元素包含键(key)和值(vaule)，中间用冒号 ：分开。冒号左边是key，一定要用不可变类型，比如字符串，我们可以通过key访问到vaule。

dict的定义用法

需要优先掌握的操作1.dictl['key'] 按key取值2.len 长度(统计的是元素个数)3.in/not in成员运算 (返回布尔值)4.d.get('key') 按key取值5.pop6.deldictl[] 删除(指定key删除，无返回值)7.键:key 值:values 键值对:items()8.for i in dic.iteml()

dict1 = {'name': 'lalal', 'age': 27, 'gender': 'male'}print(dict1["name"]) #lalal 按key取值

print(dict1.get("age")) #27 按key取值,如果不存在这个key则返回None，不会报错

dict1["name"] = "dz" #当指定的key存在时，修改对应的vaule。如果不存在，则新增元素。

print(dict1['name']) #dz

dict1.setdefault("age",20) #指定的key存在时，不修改对应的vaule；若不存在，则新增元素。返回值是key对应的vaule

print(dict1) #{'name': 'lalal', 'age': 27, 'gender': 'male'}

print(dict1.setdefault("age",20)) #27

print(dict1.pop("name")) #lalal 删除key所在的元素，并返回vaule，如果不存在会报错

print(dict1) #{'age': 27, 'gender': 'male'}

print(dict1.popitem()) #('gender', 'male') 随机删除一个元素，以元组的形式返回此元素

print(dict1) #{'name': 'lalal', 'age': 27}

print(dict1.keys()) #输出键 dict_keys(['name', 'age', 'gender'])

print(dict1.values()) #输出值 dict_values(['lalal', 27, 'male'])

print(dict1.items()) #输出键值对 dict_items([('name', 'lalal'), ('age', 27), ('gender', 'male')])

以上三个输出的返回值是可迭代对象，可以用for 遍历出元素for k indict1.keys():print(k) #name age gender

for v indict1.values():print(v) #lalal 27 male

for k, v indict1.items():print(k, v)#name lalal#age 27#gender male

需要优先掌握的操作

需要掌握的操作1.fromkeys 初始化一个字典2.update 更新字典3.setdefault

dict1 = {'name', 'age', 'gender'}

d={}.fromkeys(dict1,None) #初始化一个vaule为None的字典

print(d) #{'name': None, 'age': None, 'gender': None}

dic1= {'name': 'lalal', 'age': 27, 'gender': 'male'}

d.update(dic1)#更新字典，更新原有key对应的vaule，并增加原来没有的元素

print(d) #{'gender': 'male', 'name': 'lalal', 'age': 27}

需要掌握(初始化、更新dict)

存多值、无序、可变

五、布尔bool：描述两种状态，True、False (注意大小写).

if 3>2:print(3>2) #True

print(type(3>2)) #

所有的数据类型自带bool值

布尔值为False：0，None，空(比如空字符串""，空列表[])

bool的定义用法

所有的数据类型自带bool值，需要注意：

0，None，空(比如空字符串""，空列表[])的布尔值为False

六、元组tuple：相当于一个不可变列表，形式上是在()内用，将多个任意类型的元素隔开定义一个元组调用了tuple() 函数，tuple()函数接收一个可迭代对象，将其转换为元组的元素。

元组可视为不可修改的列表。修改元组内元素会报错，但是:

t=(1,"1",[1,2,3]) #定义一个元组

t[2][0] = "hello"

print(t) #(1, '1', ['hello', 2, 3])

元组里的内容的确修改了，实际上，元组内存储的是vaule的地址，修改列表内的元素并不会改变地址

tuple的定义用法

需要优先掌握的操作1.tuplel[0] 按索引取值2.tuplel[1:3:2] 切片(顾头不顾尾，步长)3.len 长度(统计的是元素个数)4.in/not in成员运算 (返回布尔值)5.for i in tuplel

t = ['a', 'b', 'c', 'd', 'e']print(t[0], t[0:2:1]) #a ['a', 'b']按索引取值、切片(返回子列表)，与字符串切片方法相同

t[2] = "C" #替换索引位置元素

print(t,len(t)) #['a', 'b', 'C', 'd', 'e'] 5 返回列表与元素个数(长度)

print("a" in t) #True in/not in成员运算

for item in t: #遍历列表

print(item) #a b C d e

需要优先掌握的操作

需要掌握的操作1.count 计数2.index 索引所在位置，可以指定起始范围

t = ['a', 'b', 'c', 'd', 'e']print(t.index('d',1,5)) #3 找到索引d在元组(范围1~5)中所在的位置，

print(t.count('a')) #1 计a的个数

需要掌握的操作

存多值、有序、不可变

七、集合set：用{ }的形式表示，内部元素用 ， 分隔

集合的主要用途：I关系运算  II去重(局限性：1.只针对不可变类型 2.不能保证原来顺序，可用set.index)

集合是无序的，其中的元素必须是不可变类型，并且没有重复元素。定义集合会调用 set() 函数，该函数会生成一个集合，去除重复元素。

set1= set([1, 'a', 'b'])

set2= set("hello")print(set1, set2) #{1, 'a', 'b'} {'e', 'o', 'h', 'l'}

set的定义用法

需要优先掌握的操作1.len 长度(统计的是元素个数)2.in/not in成员运算 (返回布尔值)3.|合集4.&交集5.-差集6.^对称差集7.==

8.>=父集9.<=子集

s1 = {"张","王","李","赵"}

s2= {"赵","钱","孙","李"}print(s1|s2) #并集 {'王', '李', '赵', '钱', '张', '孙'}

print(s1&s2) #交集 {'李', '赵'}

print(s1-s2) #差集 {'王', '张'}

print(s2-s1) #{'钱', '孙'}

print(s1^s2) #{'王', '钱', '张', '孙'} 对称差集：没有同时存在与s1和s2的元素

print(s1==s2) #False 判断两集合是否相等

print(s2>=s1) #False 判断s2是否包含s1(s2是否为s1的父集)(s1是否为s2的子集)

print(s2<=s1) #False

需要优先掌握的操作

需要掌握的操作1.update2.pop3.remove4.discard

s1 = {"张","王","李","赵"}print(len(s1)) #4

print(s1.pop()) #李

s1.add("刘") #添加元素，无返回值。

print(s1) #{'王', '刘', '张', '李', '赵'}

s1.update('钱') #更新集合，无返回值

print(s1) #{'李', '钱', '赵', '王', '张'

s1.remove('王') #移除，无返回值。删除集合中没有的元素时会报错

print(s1) #{'李', '张', '赵'}

s1.discard('张') #移除，无返回值。删除集合中没有的元素时不会报错

print(s1) #{'李', '赵', '王'}

需要掌握的操作

存多值、无序、可变

八、None：代表没有任何东西，它甚至没有任何类型

None的定义用法print(type(None)) #

类型小结

1)按存值个数分

存单个(标量／原子类型):字符串

存多个(容器类型):列表、元组、字典(、集合)

2)按可变不可变分

可变:列表、字典、可变集合

不可变:数字、字符串、元组、不可变集合

(set —— 可变集合。集合中的元素可以动态的增加或删除。frozenset —— 不可变集合。集合中的元素不可改变。)

3)按访问顺序分

直接取:数字

索引取:字符串、列表、元组

key取: 字典

4)按有无序分

有序:列表、元组、字符串

无序:字典、集合

5)按存储空间的占用分(从低到高)

数字

字符串

集合：无序，即无序存索引相关信息

元组：有序，需要存索引相关信息，不可变

列表：有序，需要存索引相关信息，可变，需要处理数据的增删改

字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改