定义：

age = 10 # age=int(10)
salary=3.1 # salary=float(3.1)

类型转换

• 纯数字的字符串转成int

res=int('100111')
print(res,type(res))
# 100111 <class 'int'>

res=float("3.1")
print(res,type(res))
#3.1 <class 'float'>

进制转化

• 二进制：bin()
• 八进制：oct()
• 十六进制：hen()

#其他制转成其十进制
# 二进制->10进制
# print(int('0b1011',2)) # 11

# 二进制->8进制
# print(int('0o13',8)) # 11

# 二进制->16进制
# print(int('0xb',16)) # 11

2.字符串类型(str)

定义

# 定义：在单引号双引号三引号内包含一串字符
name1 = 'jason'  # 本质:name = str('任意形式内容')
name2 = "lili"  # 本质:name = str("任意形式内容")
name3 = """ricky"""  # 本质:name = str("""任意形式内容""")

类型转换

• str可以把任意其他类型都转成字符串

res=str({'a':1})
print(res,type(res))
#{'a': 1} <class 'str'>

2.1内置方法

1.按索引取值

正向取值

msg = 'hello world'
print(msg[0])#h
print(msg[6])#w

反向取值

msg = 'hello world'
print(msg[-1])#d

只能取，不能改

msg[0] = 'H'    #会提示报错

2.切片：索引的拓展应用，从一个大字符串中拷贝出一个子字符串

顾头不顾尾

msg='hello world'
res=msg[1:7] #从下标1（也就是第2个字符）开始取，取到下标7-1（第7个字符），空格占1个字符串
print(res)# ello w

步长

msg='hello world'
res=msg[0:5:2] # 从下标0（也就是第1个字符）开始取，取到下标6-1（第5个字符），步长为2
print(res) # hlo

反向步长

msg='hello world'
res=msg[5:0:-1] # 从下标5（也就是第6个字符）开始取，取到下标0（第1个字符），步长为-1
print(res)# olle

正常取值

msg='hello world'
res=msg[:] # 相当于res=msg[0:11]
print(res)

hello world

反向取值

msg='hello world'
res=msg[::-1] # 把字符串倒过来
print(res)

dlrow olleh

3.长度len

msg='hello world'
res = len(msg)  # len用于计算字符串的长度，输出的类型为str
print(msg,type(msg))

hello world <class 'str'>

4.成员运算in和not in

判断一个子字符串是否存在于一个大字符串中

print("alex" in "alex is sb")
True
print("alex" not in "alex is sb")
False
print(not "alex" in "alex is sb") # 不推荐使用
False

5.移除字符串左右两侧的符号strip

默认去掉的是空格

msg='      egon      '
res=msg.strip()
print(msg) # 不会改变原值
print(res) # 是产生了新值

      egon      
egon

可以去掉指定的字符

msg='****egon****'
print(msg.strip('*'))
egon
msg='**/*=-**egon**-=()**'
print(msg.strip('*/-=()'))
egon

strip只去两边，不去中间

msg='****e*****gon****'
print(msg.strip('*'))
#e*****gon

inp_user=input('your name>>: ').strip() # inp_user=" egon"
inp_pwd=input('your password>>: ').strip()
if inp_user == 'egon' and inp_pwd == '123':
    print('登录成功')
else:
    print('账号密码错误')

6.切分split：把一个字符串按照某种分隔符进行切分，得到一个列表

默认分隔符是空格

info='egon 18 male'
res=info.split()
print(res)

['egon', '18', 'male']

可以指定分隔符

info='egon:18:male'
res=info.split(':')
print(res)

['egon', '18', 'male']

可以指定分隔次数(了解)

info='egon:18:male'
res=info.split(':',0)   # 分隔次数为0，就是不分隔
print(res)

['egon:18:male']
info='egon:18:male'
res=info.split(':',1)
print(res)

['egon', '18:male']

7.循环

info='egon:18:male'
for x in info:
    print(x)

8.strip、lstrip、rstrip

strip：移除字符串中指定的符号
lstrip：移除字符串左侧指定的符号
**rstrip：移除字符串右侧指定的符号 **

msg='***egon****'
print(msg.strip('*'))   # 可以移除字符串中指定的符号

9.lower、upper

lower：把字符串中所有字母变成小写字母
upper：把字符串中所有字母变成大写字母

msg='AbbbCCCC'
print(msg.lower()) # abbbcccc
msg='AbbbCCCC'
print(msg.upper())#  ABBBCCCC

10.startswith、endswith

startswith：用于判断一段字符串是否以某段字符或者某个字符串开头
endswith：用于判断一段字符串是否以某段字符或者某个字符串结尾

print("alex is sb".startswith("alex"))# True
print("alex is sb".endswith('sb')) # True

11.format：格式化输出

其实就是format()后面的内容，填入大括号中（可以按位置，或者按变量）

res='我的名字是 {} 我的年龄是 {}'.format('egon',18)
print(res)

我的名字是 egon 我的年龄是 18

12.split、rsplit：将字符串切成列表

split：从左往右切分
rsplit：从右往左切分

info="egon:18:male"
print(info.split(':',1)) # ['egon', '18:male']
print(info.rsplit(':',1)) # ["egon:18","male"]

13.join: 把列表拼接成字符串

按照某个分隔符号，把元素全为字符串的列表拼接成一个大字符串

l=['egon', '18', 'male']
res=l[0]+":"+l[1]+":"+l[2]
res=":".join(l) 
print(res)

egon:18:male

14.replace：替换

msg="you can you up no can no bb"
print(msg.replace("you","YOU",))

YOU can YOU up no can no bb

可以自定义要替换几个

msg="you can you up no can no bb"
print(msg.replace("you","YOU",1))

YOU can you up no can no bb

15.isdigit：判断字符串是否由纯数字组成

print('123'.isdigit())#True
print('12.3'.isdigit())#False

16.find、rfind、index、rindex、count

find：找到返回起始索引

msg='hello egon hahaha'
print(msg.find('e')) # 1  返回要查找的字符串在大字符串中的起始索引
print(msg.find('egon'))# 6

index 查找索引,没有找到抛出异常

print(msg.index('xxx')) # 抛出异常
ValueError: substring not found

count：计算字符串在大字符串中出现的次数

msg='hello egon hahaha egon、 egon'
print(msg.count('egon')) # 3

17.center、ljust、rjust、zfill

center：在center内容中间添加内容
ljust：在ljust内容左边添加内容
rjust：在ljust内容右边添加内容
zfill：在zfill内容中加到指定个数

print('egon'.center(50,'*'))
print('egon'.ljust(50,'*'))
print('egon'.rjust(50,'*'))
***********************egon***********************
egon**********************************************
**********************************************egon
print('egon'.zfill(10))
#000000egon

18.expandtabs

设置制表符代表的空格数

msg='hello	world'
print(msg.expandtabs(2)) # 设置制表符代表的空格数为2

#hello world

19.captalize、swapcase、title

captalize：一段字符串的首个字母大写，其余小写

print("hello world egon".capitalize())

Hello world egon

swapcase：一段字符串的首个字母小写，其余大写

print("Hello WorLd EGon".swapcase())

hELLO wORlD egON

title：每个单词的首字母大写，其余小写

print("hello world egon".title())

Hello World Egon

20.is系列

.isdigit()：判断是否全部都是纯数字类型
.islower()：判断是否全部都是小写字母
.isupper()：判断是否全部都是大写字母
.istitle()：判断是否是单词首个字母大写
.isalnum()：判断是否由数字或字母组成
.isalpha()：判断是否全部由字母构成
.isspace()：判断是否全部由空格构成
.isidentifier()：判断是否可以定义为变量名

print('123'.isdigit())#True
print('abc'.islower())#True
print('ABC'.isupper())#True
print('Hello World'.istitle())#True
print('123123aadsf'.isalnum()) # 字符串由字母或数字组成结果为True
print('ad'.isalpha()) # 字符串由由字母组成结果为True
print('     '.isspace()) # 字符串由空格组成结果为True
print('print'.isidentifier())#True
print('age_of_egon'.isidentifier())#True
print('1age_of_egon'.isidentifier())#False   # 变量名不能以数字开头

21.数字系列的识别

先定义表示同一个数字的4个不同方法：

num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字

isdigit只能识别：num1、num2

print(num1.isdigit()) # True
print(num2.isdigit()) # True
print(num3.isdigit()) # False
print(num4.isdigit()) # False

isnumberic可以识别：num2、num3、num4

print(num2.isnumeric()) # True
print(num3.isnumeric()) # True
print(num4.isnumeric()) # True

isdecimal只能识别：num2

print(num2.isdecimal()) # True
print(num3.isdecimal()) # False
print(num4.isdecimal()) # False

3、列表类型

作用

​ 按存储位置催多个值

定义

# l=[1,1.2,'a'] 
# l=list([1,1.2,'a'])

类型转换

res=list('hello')
print(res)

res=list({'k1':111,'k2':222,'k3':3333})
print(res)

3.1 内置方法

1.按索引存取值：既能存也能改

l=[111,'egon','hello']
#正向取
print(l[0])
#反向取
print(l[-1])
#可以取也可以改：索引存在则修改对应的值
l[0]=222
print(l)
#无论是取值操作还是赋值操作：索引不存在则报错

2.切片(顾头不顾尾，步长)

l = [111, 'egon', 'hello', 'a', 'b', 'c', 'd', [1, 2, 3]]

print(l[0:3])

print(l[0:5:2]) # 0 2 4

3.长度

print(len([1, 2, 3]))

4.成员运算in和not in

print('aaa' in ['aaa', 1, 2])
print(1 in ['aaa', 1, 2])

5.往列表中添加值

• 追加

# l=[111,'egon','hello']
# l.append(3333)
# l.append(4444)
# print(l)

• 插入值

# l=[111,'egon','hello']
# l.insert(0,'alex')
# print(l)

• extend添加值

5.3、extend添加值
# new_l=[1,2,3]
# l=[111,'egon','hello']
# l.append(new_l)
# print(l)
# 代码实现
# for item in new_l:
#     l.append(item)
# print(l)

# extend实现了上述代码
# l.extend(new_l)
# l.extend('abc')
# print(l)

6 .删除

• 方式一：通用的删除方法，只是单纯的删除、没有返回值

# l = [111, 'egon', 'hello']
# del l[1]
# x =del l[1] # 抛出异常，不支持赋值语法
# print(l)

• 方式二：l.pop()根据索引删除，会返回删除的值

# l = [111, 'egon', 'hello']
# l.pop() # 不指定索引默认删除最后一个
# l.pop()
# print(l)
# res=l.pop(1)
# print(l)

# print(res)

• 方式三：l.remove()根据元素删除，返回None

# l = [111, 'egon', [1,2,3],'hello']
# l.remove([1,2,3])
# print(l)
# res=l.remove('egon')
# print(res) # None

7.循环

# l=[1,'aaa','bbb']
# for x in l:
#     l.pop(1)
#     print(x)

8 .count():记录出现次数

l = [1, 'aaa', 'bbb','aaa','aaa']
# print(l.count('aaa'))

9 .index():记录查询到值的第一个索引

l = [1, 'aaa', 'bbb','aaa','aaa']
# print(l.index('aaa'))
# print(l.index('aaaaaaaaa')) # 找不到报错

10 .clear():清空列表

# l.clear()
# print(l)

11 .reverse():将列表倒置

# l = [1, 'egon','alex','lxx']
# l.reverse()
# print(l)

8 .sort():列表排序（需同种元素）

# l=[11,-3,9,2,3.1]
# l.sort() # 默认从小到大排，称之为升序
# l.sort(reverse=True) # 从大到小排，设置为降序
# print(l)

补充：

1、队列：FIFO,先进先出

# l=[]
# # 入队操作
# l.append('first')
# l.append('second')
# l.append('third')
#
# print(l)
# # 出队操作
# print(l.pop(0))
# print(l.pop(0))
# print(l.pop(0))

2、堆栈：LIFO,后进先出

l=[]
# 入栈操作
l.append('first')
l.append('second')
l.append('third')

print(l)
# 出队操作
print(l.pop())
print(l.pop())
print(l.pop())

4、元组

作用

​ 按照索引/位置存放多个值，只用于读不用于改

定义

• 元组就是"一个不可变的列表"
• （）内用逗号分隔开多个任意类型的元素
• 元组定义好后，内存地址是不能更改的，但对于值是可变类型来说，值仍是可以改变的

# t=(1,1.3,'aa') # t=tuple((1,1.3,'aa'))
# print(t,type(t))

# x=(10) # 单独一个括号代表包含的意思
# print(x,type(x))

# t=(10,) # 如果元组中只有一个元素，必须加逗号
# print(t,type(t))

类型转换

# print(tuple('hello'))
# print(tuple([1,2,3]))
# print(tuple({'a1':111,'a2':333}))

4.1内置方法

1 按索引取值(正向取+反向取)：只能取

# t=('aa','bbb','cc')
# print(t[0])
# print(t[-1])

2 切片(顾头不顾尾，步长)

# t=('aa','bbb','cc','dd','eee')
# print(t[0:3])
# print(t[::-1])

3 长度

# t=('aa','bbb','cc','dd','eee')
# print(len(t))

4 成员运算in和not in

# print('aa' in t)

5 循环

# for x in t:
#     print(x)

6 index和count

t=(2,3,111,111,111,111)
# print(t.index(111))#查询值的索引
# print(t.index(1111111111))#找不到就报异常

print(t.count(111))#计算出现次数

5、字典

作用 ：

​ 存放键值对（key : value）

定义;

• {}内用逗号分隔开多个key：value(键值对)
• 其中value可以使任意类型，但是key必须是不可变类型,且不能重复

造字典的方式一：

# d={'k1':111,(1,2,3):222} # d=dict(...)
# print(d['k1'])
# print(d[(1,2,3)])
# print(type(d))

# d={} # 默认定义出来的是空字典
# print(d,type(d))

造字典的方式二：

# d=dict(x=1,y=2,z=3)
# print(d,type(d))

造字典的方式三：

# info=[
#     ['name','egon'],
#     ('age',18),
#     ['gender','male']
# ]
# res=dict(info) # 一行代码搞定上述for循环的工作
# print(res)

造字典的方式四：快速初始化一个字典

# keys=['name','age','gender']
# d={}
# for k in keys:
#     d[k]=None
# print(d)
# d={}.fromkeys(keys,None) # 一行代码搞定上述for循环的工作
# print(d)

数据类型转换

# info=[
#     ['name','egon'],
#     ('age',18),
#     ['gender','male']
# ]
# d={}
# for k,v in info: # k,v=['name','egon'],
#     d[k]=v
# print(d)
#

5.1 内置方法

1、按key存取值：可存可取

# d={'k1':111}
# 针对赋值操作：key存在，则修改
# d['k1']=222
# 针对赋值操作：key不存在，则创建新值
# d['k2']=3333

2、长度len

# d={'k1':111,'k2':2222,'k1':3333,'k1':4444}
# print(d)
# print(len(d))

3、成员运算in和not in:根据key

# d={'k1':111,'k2':2222}
# print('k1' in d)
# print(111 in d)

4、删除

• 通用删除

d={'k1':111,'k2':2222}
# del d['k1']
# print(d)

• pop删除：根据key删除元素，返回删除key对应的那个value值

d={'k1':111,'k2':2222}
# res=d.pop('k2')
# print(d)
# print(res)

• popitem删除：随机删除，返回元组(删除的key,删除的value)

d={'k1':111,'k2':2222}
# res=d.popitem()
# print(d)
# print(res)

5、键keys()，值values()，键值对items()

在python2中
>>> d={'k1':111,'k2':2222}
>>> 
>>> d.keys()
['k2', 'k1']
>>> d.values()
[2222, 111]
>>> d.items()
[('k2', 2222), ('k1', 111)]
>>> dict(d.items())
{'k2': 2222, 'k1': 111}

6、for循环

for k in d.keys():
    print(k)
for k in d:
    print(k)
for v in d.values():
    print(v)
for k,v in d.items():
    print(k,v)

print(list(d.keys()))
print(list(d.values()))
print(list(d.items()))

7、d.clear()

d={'k1':111}
d.clear()#清空字典

8、d.update()

d={'k1':111}
# d.update({'k2':222,'k3':333,'k1':111111111111111})
# print(d)

9、d.get() 根据key取值，容错性好

d={'k1':111}
# print(d['k2'])  # key不存在则报错

# print(d.get('k1')) # 111
# print(d.get('k2')) # key不存在不报错，返回None

10、d.setdefault()

• 如果key有则不添加,返回字典中key对应的值

info={'name':'egon'}
res=info.setdefault('name','egon')
# print(info)

print(res)

• 如果key没有则添加，返回字典中key对应的值

info={}
res=info.setdefault('name','egon')
# print(info)
print(res)

6. 集合

作用

​ 集合、list、tuple、dict一样都可以存放多个值，

​ 集合主要用于：去重、关系运算

定义:

​ 在{}内用逗号分隔开多个元素，多个元素满足以下三个条件

• 集合内元素必须为不可变类型
• 集合内元素无序
• 集合内元素没有重复

 s={1,2} # s=set({1,2})

 s={1,[1,2]} # 集合内元素必须为不可变类型
 s={1,'a','z','b',4,7} # 集合内元素无序
 s={1,1,1,1,1,1,'a','b'} # 集合内元素没有重复
 print(s)

 s={}# 默认是空字典
 print(type(s))

定义空集合
 s=set()
 print(s,type(s))

类型转换

 set({1,2,3})
 res=set('hellolllll')
 print(res)

 print(set([1,1,1,1,1,1]))
 print(set([1,1,1,1,1,1,[11,222]]) # 报错

 print(set({'k1':1,'k2':2}))

6.1 内置方法

• 关系运算符

friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}

1 取交集：两者共同的好友

 res=friends1 & friends2
 print(res)
 print(friends1.intersection(friends2))

2 取并集/合集：两者所有的好友

 print(friends1 | friends2)
 print(friends1.union(friends2))

3 取差集：（注意：取到的是-前面集合独有的元素）

#取friends1独有的好友
 print(friends1 - friends2)
 print(friends1.difference(friends2))

# 取friends2独有的好友
 print(friends2 - friends1)
 print(friends2.difference(friends1))

4 对称差集: 求两个用户独有的好友们（即去掉共有的好友）

 print(friends1 ^ friends2)
 print(friends1.symmetric_difference(friends2))

5 父子集：包含的关系

 s1={1,2,3}
 s2={1,2,4}
不存在包含关系，下面比较均为False
 print(s1 > s2)
 print(s1 < s2)

 s1={1,2,3}
 s2={1,2}
 print(s1 > s2) # 当s1大于或等于s2时，才能说是s1是s2他爹
 print(s1.issuperset(s2))
 print(s2.issubset(s1)) # s2 < s2 =>True

 s1={1,2,3}
 s2={1,2,3}
 print(s1 == s2) # s1与s2互为父子
 print(s1.issuperset(s2))
 print(s2.issuperset(s1))

去重

6 只能针对不可变类型去重

 print(set([1,1,1,1,2]))

7 无法保证原来的顺序

 l=[1,'a','b','z',1,1,1,2]
 l=list(set(l))
 print(l)

l=[
{'name':'lili','age':18,'sex':'male'},
{'name':'jack','age':73,'sex':'male'},
{'name':'tom','age':20,'sex':'female'},
{'name':'lili','age':18,'sex':'male'},
{'name':'lili','age':18,'sex':'male'},
]
new_l=[]
for dic in l:
if dic not in new_l:
new_l.append(dic)

 print(new_l)

8 长度

s={'a','b','c'}
len(s)
3

9 成员运算

'c' in s
True

10 循环

for item in s:
	print(item)

11 discard

s={1,2,3}
s.discard(4)                        # 删除元素不存在do nothing
 print(s)
 s.remove(4)                       # 删除元素不存在则报错

12 update

 s.update({1,3,5})
 print(s)

13 pop

 res=s.pop()
 print(res)

14 add

 s.add(4)
 print(s)

了解的内置方法

res=s.isdisjoint({3,4,5,6})   # 两个集合完全独立、没有共同部分，返回True
print(res)
 s.difference_update({3,4,5}) # s=s.difference({3,4,5})
 print(s)