一，数字类型

1) 定义,整型

age=10
print(age,type(age))

10 <class 'int'>

2) 类型转换

# 字符串类型转换为数字类型
a='123'
print(type(a))

a=int(a)
print(type(a))


<class 'str'>
<class 'int'>

二，字符串类型

1) 定义

# 定义：在单引号\双引号\三引号内包含一串字符
name1='lili'
name2="pp"
name3='''bb'''

2) 类型转换

# 列表转字符串
name1=['lili','pp','bb']
print(type(name1))
name1=str(['lili','pp','bb'])
print(type(name1))

<class 'list'>
<class 'str'>



# 字典转字符串
info={"name":"mz","gender":"male"}
print(type(info))
info=str({"name":"mz","gender":"male"})
print(type(info))

<class 'dict'>
<class 'str'>

3) 索引取值

info = 'good morning'

# 正向取值
print(info[0])
g


# 反向取值
print(info[-2])
n

4）切片

info = 'good morning'

# 取出索引为0-12的所有字符
print(info[0:12])

good morning




# 反向切片，-1代表从右往左一次取值
print(info[::-1])

gninrom doog



# 第三个参数3代表步长，从索引0开始，每次累加3
info = 'good morning'
print(info[0:12:3])


gdoi






# 复制切片
msg='hello world'
print(msg[:])
print(msg[::-1])

hello world
dlrow olleh


# 取值第五个索引到第0个索引，反着取，顾头不顾尾
print(msg[5:0:-1])

 olle

5) 字符串长度

# 空格也算一个字符
info = 'good morning'
print(len(info))

12

6）in / not in 判断

info = 'good morning'

# 判断good是否在字符info里
print('good' in info)

# 判断bad是否不在字符info里
print('bad' not in info)


True
True

7) strip lstrip rstrip移除字符串首尾制定的字符

--------------------------------strip

# 默认去除空格
name='    mz   '
print(name)
print(name.strip())

    mz   
mz




# 去除制定字符
info='###mz###%'
print(info.strip('#%'))

mz





--------------------------------lstrip

# 移除左边的字符
info = '&&&& mz $$$'
print(info.lstrip('& '))

mz $$$





--------------------------------rstrip

# 移除右边的字符
info = '&&&& mz $$?'
print(info.rstrip('$ ?'))


&&&& mz

8) split / rsplit切分

--------------------------split
# 括号内不指定字符，默认以空格作为切分符号
info='hello baby'
print(info.split())

['hello', 'baby']



info='10.0.0.6'
print(info.split('.'))

['10', '0', '0', '6']





abc='C:/a/c/c.txt'
# 切割1次
print(abc.split('/',1))
# 切割2次
print(abc.split('/',2))

['C:', 'a/c/c.txt']
['C:', 'a', 'c/c.txt']






info="egon:16:female"

# 代表取出0，1，2的索引的值
res=info.split(':',2)
print(res)

['egon', '16', 'female']





注意:
split切割得到的结果是列表数据类型






---------------------------rsplit

# rsplit刚好与split相反，从右往左切割，可以指定切割次数
abc='a|b|c|d'
# 切割1次
print(abc.rsplit('|',1))

# 切割2次
print(abc.rsplit('|',2))

['a|b|c', 'd']
['a|b', 'c', 'd']




备注：
例（2www2eee2rrr）
如果以上按照2切分，那么得到第一个字符合作最后一个字符都是空

info="2www2ee2"
print(info.split('2'))

['', 'www', 'ee', '']

9) 循环

info='hello?'
for i in info:
    print(i)



h
e
l
l
o
?

10) lower(),upper() 字符串大小写

# 将英文字符串全部变成大写
name='muzhi'
print(name.upper())

MUZHI



# 将英文字符串全部变成小写
name='MUzHI'
print(name.lower())

muzhi

11）startswith,endswith

----- 判断字符串是否以括号内指定的字符结尾 / 开始

# 判断字符info是否以girl为结尾
info='beautiful_girl'
print(info.endswith('girl'))

True



# 判断字符info是否以abc为开始
info='beautiful_girl'
print(info.startswith('abc'))

False

12）格式化输出 format

# 方式一
info='my name is %s,my age is %s' %('mz',13)
print(info)


# 方式二
info='my name is {x},my age is {y}'.format(x='mz',y=13)
print(info)



# 方式三
# 类似于%s的用法，传入的值会按照位置与{}一一对应
info='my name is {},my age is {}'.format('mz',13)
print(info)



# 方式四：
# 把format传入的多个值当作一个列表，然后用{索引}取值
info='my name is {0},my age is {1}'.format('mz',13)
print(info)



my name is mz,my age is 13





PS:

info='my name is {x}{x},my age is {y}{y}'.format(x='mz',y=13)
print(info)

my name is mzmz,my age is 1313

13）join 拼接（把一个纯字符串组成的列表拼接成字符串）

#join拼接：把一个纯字符串组成的列表拼接成字符串

l=["mz","18",'female']
rres=":".join(l)
print(rres)

mz:18:female




print('---'.join('abc'))

print('**'.join('hello'))

a=('11','22','33')
aa="*".join(a)

print(aa)


a---b---c
h**e**l**l**o
11*22*33


注意：
必须是字符串，数字类型会报错
a=('11','22','33')要加引号

14) replace 新的字符替换字符串中旧的字符

# 以下出现2个“mz”， 1代表只把第一个mz替换
info='my name is mz , my bbs name is mz,my age is 88'
info2=info.replace('mz','mm',1)
print(info2)


my name is mm , my bbs name is mz,my age is 88

15） isdigit

--------- 判断字符串是否是纯数字组成，返回结果为True或False

a='333'
print(a.isdigit())

True





b='333lg'
print(b.isdigit())


False

三，列表类型

1，用途

用途：按照索引记录多个值，索引反映的是位置

2，定义方式

定义方式： 在[ ]内用逗号分隔开个多个任意类型的元素

#例
res=["aaa",222,['aa','bb'],"pp"]
print(type(res))

 <class 'list'>




#例1
info='hello'
print(type(info))

<class 'str'>





# 例2
info=list(info)
print(type(info))

<class 'list'>





# 例3
# # list数据类型转换：能够被for循环遍历的类型，都可以被list转成列表

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

['k1', 'k2', 'k3']

3，取 / 替换值

# 按照索引取值
info=["mz","egon",33]



# 正向取值
print(info[0])
# mz

# 反向取值
print(info[-1])
# 33

# 查看id
print(id(info))
# 4333209728

# 根据列表索引替换对应的值，字符串不可以这么做
info[2]="tom"
print(info)
# ['mz', 'egon', 'tom']


# 不可以操作不存在的索引
info[2]="pp" # 会报错

# 可以insert，补充索引和对应的值
info.insert(3,"lily")
print(info)
# ['mz', 'egon', 'tom', 'lily']

4，切片

#切片(顾头不顾尾，步长)
info=[11,22,33,44,55]

# 索引0-4，步长为1（0索引累加1个索引，得出值）
print(info[0:4:1])
# [11, 22, 33, 44]

# 索引1-4之间，步长为2（索引1开始，累加2个索引，得出值）
print(info[1:4:2]) 
# [22, 44]




# 浅拷贝
print(info[:])
# [11, 22, 33, 44, 55]

# 反向取值
print(info[::-1])
# [55, 44, 33, 22, 11]

5，长度

# 长度
info = [11,22,33]
print(len(info))
# 3

6，成员运算in / not in

info=[11,22,33]


# 判断22是否在列表info里
print(22 in info)
# True

易错
# 注意这里22加上引号是字符串
print("22" in info)
# False


info=[11,22,33]
print(77 not in info)
# True

7，追加 / 插入

# append 默认追加在最后，只能追加一个元素
info=[11,22,33]
info.append(44)
print(info)
# [11, 22, 33, 44]



# extend 一次性在列表最后加入多个元素，注意要加上列表中括号
info=[11,22,33,44]
info.extend([55,'66'])
print(info)
# [11, 22, 33, 44, 55, '66']



# insert 在指定位置上插入元素,注意这里可以不用给元素加上引号，不然识别的元素也会加上引号
info=[11,22,33]
info.insert(3,'44')
print(info)
# [11, 22, 33, '44']




# insert 指定索引更改元素
info=[11,22,33]
# 索引0增加元素99
info.insert(0,99)
print((info))
# [99, 11, 22, 33]

8，删除 del / pop / remove

1) del

# del删除，不返回删除值
info=[11,22,33]
del info[2]
print(info)
# [11, 22]

2) pop

# pop  pop()默认删除列表最后一个元素,也可以指定索引删除
info=[11,22,33]
print(info.pop())
# 33
print(info)
# [11, 22]




# 指定索引,删除索引1的值
info=[11,22,33]
print(info.pop(1))
# 22

3) remove

# remove()括号内指名道姓表示要删除哪个元素，没有返回值
info=[11,22,33]
info.remove(11)
print(info) 
# [22, 33]

9，reverse( ) 颠倒列表内元素的顺序

info=[11,22,33]
info.reverse()
print(info)
# [33, 22, 11]

等同于

info=[11,22,33]
print(info[::-1])
# [33, 22, 11]

10，sort()给列表内所有元素排序

# sort排序（从小到大）
info=[88,33,22]
info.sort()
print(info)
# [22, 33, 88]

# sort + reverse,指定排序并颠倒
info=[3,5,1,4,3]
info.sort(reverse=True)
print(info)
# [5, 4, 3, 3, 1]

# sort + reverse,指定排序并从小到大排列（多余，可以直接用sort）
info=[3,5,1,4,3]
info.sort(reverse=False)
print(info)
# [1, 3, 3, 4, 5]




PS：
# 列表元素数量不同，也比较大小
a=[1,2]
b=[3]
print(a > b)

# 字符也可以比大小
s1='abc'
s2='t'
print(s1 > s2)


# 列表里的字符排序
info=['aw','bb','kk']
info.sort()
print(info)
# ['aw', 'bb', 'kk']



# 列表里的字符和数字不可以排序（会报错）
info=['aw',44,'kk']
info.sort()
print(info)

# 44加引号 "44",不会报错
# # ['44', 'aw', 'kk']

11，循环

# 循环
my_friend=['tom','peter','bb']
for i in my_friend:
    print(i)
# tom
# peter
# bb

四，元祖类型

1，元祖类型定义

info=('abc','bcd')
print(type(info))
# <class 'tuple'>

PS:
# 不要混淆字符串类型是一个元素，元祖类型是多个元素
info=('abc')
print(type(info))
# <class 'str'>

2，类型转换

# 类型转换
# 列表类型转元祖类型
info=tuple([1,2,3])
print(info)
# (1, 2, 3)


# 字典类型转元祖类型
info=tuple({"name":"mz","age":25})
print(info)
# ('name', 'age')

3，使用

1) 索引取值
tuple1=(11,22,33)
print(tuple1[0])


2) 切片（顾头不顾尾，步长）
tuple1=(11,22,33)

# 倒序取值
print(tuple1[::-1])
# (33, 22, 11)

# 索引1-3之间，索引3不算（顾头不顾尾），步长为1 取值
tuple1=(11,22,33,44,55)
print(tuple1[1:3:1])
# (22, 33)



3) 长度
tuple1=(11,22,33)
print(len(tuple1))


4) 成员运算
tuple1=(11,22,33)
print('aa' in tuple1)
# False


print(11 in tuple1)
# True



5）循环
# 循环
tuple1=(11,22,33)
for i in tuple1:
    print(i)
# 11
# 22
# 33

五，字典类型

1，定义方式

在{}内用逗号分割开多个元素，其中每个元素都是由key:value的格式的组成
key，      必须是不可变类型（通常为字符串类型）
value，    可以是任意类型



dicc={"k1":22,"k2":"dd"}
print(type(dicc))
print(dicc["k1"])
#<class 'dict'>
#22

2，类型转换

# 字符串类型转换为列表类型
info=list('hello')
print(info)
# ['h', 'e', 'l', 'l', 'o']




# 原列表类型，转换为字典类型
info=[("name","muzhi"),("age",18)]
print(info,type(info))
#[('name', 'muzhi'), ('age', 18)] <class 'list'>


new_info=dict(info)
print(new_info)
# {'name': 'muzhi', 'age': 18}

3，常用操作+内置的方法

1.1)按key存取值（可存可取）

info={"name":"muzhi","age":66,"gender":"male"}
print(info["name"])
# muzhi


# 对于字典类型，可以根据不存在的key往里添加一组元素
info["hobby"]="sing"
print(info)
# {'name': 'muzhi', 'age': 66, 'gender': 'male', 'hobby': 'sing'}

1.2)get取值

info={"name":"muzhi","age":66,"gender":"male"}
print(info.get("name"))
# muzhi

# 取一个不存在的key值，返回None
print(info.get("name2"))
# None

2，长度

# 按照多少个key值得出长度
info={"name":"muzhi","age":66,"gender":"male"}
print(len(info))
# 3

3，成员运算in和not in

根据key判断

info={"name":"tom","age":18,"gender":"male"}
# 根据key值判断
print("name" in info)
# True


# 根据value判断，False
print("male" in  info)
# False

4，删除

#del 万能删除
info={"name":"tom","age":18}
del info['age']
print(info)
# {'name': 'tom'}




# pop 删除（有返回值，返回value值）
info={"name":"tom","age":18}
res=info.pop("name")
print(res)
#tom




# popitem 随机删
info={"name":"tom","age":18}
res=info.popitem()
print(res)
# ('age', 18)

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

# dic.keys()
# dic.values()
# dic.items()




info={"name":"tom","age":18,"gender":"female"}
# 只取出key值
print(info.keys())
# dict_keys(['name', 'age', 'gender'])



# 只取出value值
print(info.values())
# dict_values(['tom', 18, 'female'])



print(info.items())
#dict_items([('name', 'tom'), ('age', 18), ('gender', 'female')])

6，循环

info={"name":"tom","age":18,"gender":"female"}

# 取出key值
for k in info.keys():
    print(k)
# name
# age
# gender



# 取出value值
for v in info.values():
    print(v)
# tom
# 18
# female




for i in info.items():
    print(i)
# ('name', 'tom')
# ('age', 18)
# ('gender', 'female')

7，update / copy

info={"name":"tom","age":18,"gender":"female"}

# 把字典的name和age更新对应的值，注意语法格式update({ })有中括号
info.update({"name":"muzhi","age":99})
print(info)
# {'name': 'muzhi', 'age': 99, 'gender': 'female'}



res=info.copy()
print(res)
# {'name': 'muzhi', 'age': 99, 'gender': 'female'}

8，fromkeys

#初始化返回一个新字典，通过append赋值value
info={}.fromkeys({"id","name"},[])
info["name"].append('mmm')
print(info)
# {'name': ['mmm'], 'id': ['mmm']}


# 以上指定的是[ ] 字典，如果像赋值字符串，不可以使用append
abc={}.fromkeys({"name","age"},"")
print(abc)
abc["name"]='xxxxxx'
print(abc)
# {'age': '', 'name': 'xxxxxx'}

9，setdefault

# key不存在则新增键值对，并将新增的value返回
dic = {'name': 'egon', 'age': 18, 'gender': 'male', "level": 19}
res=dic.setdefault("hobby","sing")
print(res)
# sing
print(dic)
# {'name': 'egon', 'age': 18, 'gender': 'male', 'level': 19, 'hobby': 'sing'}



# key存在则返回对应key的value值
dic = {'name': 'egon', 'age': 18, 'gender': 'male', "level": 19}
res=dic.setdefault("name","muzhi")
print(res)
# egon


PS：
注意setdefault后面括号跟的是逗号，不是冒号






========================  等同于  ========================

dic = {'name': 'egon', 'age': 18, 'gender': 'male'}
if 'level' in dic:
    pass
else:
    dic['level']=19
print(dic)
# {'name': 'egon', 'age': 18, 'gender': 'male', 'level': 19}```

六，集合

1，作用

集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算

2，定义

定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：
     1：每个元素必须是不可变类型
     2：集合内没有重复的元素
     3：集合内元素无序


info={1,3,5,2} # 等同于   info=set({1,3,5,2})
print(info)
# {1, 2, 3, 5}


# 注意1：
列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值;
而集合类型既没有索引也没有key与值对应，所以无法取得单个的值;
对于集合来说,主要用于去重与关系元素，根本没有取出单个指定值这种需求。

# 注意2:
{}既可以用于定义dict，也可以用于定义集合
但是字典内的元素必须是key:value的格式

d = {} # 默认是空字典 
s = set() # 这才是定义空集合

3，使用

1，关系运算

- 例：for去重

例：取出以下的都有的名字

# 方式一
fridens1={"lily","tom","pepe","mmmzhi","egggg"}
friends2={"huahua","dogdog","mimi","tom","lily"}
for name in fridens1:
    if name in friends2:
        print(name)
# tom
# lily




# 方式二
fridens1={"lily","tom","pepe","mmmzhi","egggg"}
friends2={"huahua","dogdog","mimi","tom","lily"}
l=[]
for name in fridens1:
    if name in friends2:
        l.append(name)
print(l)
# ['lily', 'tom']

- 符号运算

fridens1={"lily","tom","pepe","mmmzhi","egggg"}
friends2={"huahua","dogdog","mimi","tom","lily"}
# 1，合集 / 并集 （ ｜ ）
print(fridens1 | friends2)
# {'mmmzhi', 'huahua', 'lily', 'pepe', 'tom', 'egggg', 'dogdog', 'mimi'}

# 2，交集（ & ）

# 用户一独有的好友
print(fridens1 & friends2)
# {'tom', 'lily'}

# 用户2独有的好友
print(friends2 - fridens1)
# {'mimi', 'dogdog', 'huahua'}


# 3，差集 （ - ）
print(fridens1 - friends2)
# {'egggg', 'pepe', 'mmmzhi'}


# 4，对称差集 ( ^ )
# 两个用户独有的好友，即去掉共同的好友,结果是无序的！！
print(fridens1 ^ friends2)
# {'mmmzhi', 'dogdog', 'huahua', 'pepe', 'mimi', 'egggg'}


# 5，值是否相等 ( == )
print(fridens1 == friends2)
# False


# 6，父集：一个集合是否包含另一个集合
##1） 包含则返回True
res={1,3,5} > {1,3}
print(res)
# True

res1={1,3,5} >= {1,3}
print(res1)
# True


##2） 不包含则返回False
info={1,2} > {1,2,22}
print(info)
# False


# 7，子集
res={1,2} <= {1,12,3,2}
print(res)
# True

2，类型转换 / 去重（只针对不可变类型）

1）无序去重

# 1. 只能针对不可变类型
# 2. 集合本身是无序的，去重之后无法保留原来的顺序


例：

# 列表类型转集合
l=[1,2,2,"a","c","a"]
print(type(l))
# <class 'list'>

# 转为集合
new_l=set(l)
print(new_l)
# {1, 2, 'c', 'a'}

# 再转回列表,去除了重复，但是打乱了顺序
s=list(new_l)
print(s)
# ['a', 1, 2, 'c']

2）for 循环去重（有序）

针对不可变类型，并且保证顺序则需要我们自己写代码实现


# 列表转集合（去重，无序）
相比下面的例子，同样是列表，但是列表的元素不同，这个例子中的元素是不可变类型
info=["abc","bbb","cbb","abc","bbb"]

# 转集合
new_info=set(info)
print(new_info)
# {'bbb', 'abc', 'cbb'}

info=[
    {"namw":"tom","age":77,"gender":"female","level":10},
    {"namw":"egon","age":7,"gender":"female","level":19},
    {"namw":"muzhi","age":97,"gender":"male","level":1},
    {"namw":"egon","age":7,"gender":"female","level":19},
]

# 如下列表会报错，只适用于不可变类型
new_info=set(info)
print(info)
# TypeError: unhashable type: 'dict'

new_info=[]
for name in info:
    if name not in new_info:
        new_info.append(name)
print(new_info)
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
# [{'namw': 'tom', 'age': 77, 'gender': 'female', 'level': 10}, {'namw': 'egon', 'age': 7, 'gender': 'female', 'level': 19}, {'namw': 'muzhi', 'age': 97, 'gender': 'male', 'level': 1}]

3，其他操作

#1,长度
l={1,3,6,"a"}
print(len(l))
# 4

#2，成员运算
l={1,3,6,"a"}
print("s" in l)
# False


#3, 循环
l={1,3,6,"a"}
for i in l:
    print(i)
# 1
# 3
# 6
# a

补充：可变类型/不可变类型

1）数字类型 (不可变)

x=10
print(id(x))
# 4380713520

x=3
print(id(x))
# 4380713296
# 内存地址改变了，说明整型是不可变数据类型，浮点型也一样

2）字符串 (不可变)

y='tt'
print(id(y))
# 4300352880

y='uu'
print(id(y))
# 4299950064
# 内存地址改变了，说明字符串是不可变数据类型

3）列表（可变）

list1=[11,22,"tom"]
print(id(list1))
# 4314417280

list1[2]="egon"
print(id(list1))
# 4314417280

list1.append('xxx')
print(id(list1))
# 4314417280
# 对列表的值进行操作时，值改变但内存地址不变，所以列表是可变数据类型

3） 元祖（不可变）

如果元组中存在可变类型，是可以修改，但是修改后的内存地址不变

t1=(33,'yy',['aa','bb'])
print(id(t1))

#t1[0]=66 # 会报错
#t1.append('p') # 会报错
print(id(t1[0]),id(t1[1]),id(t1[2]))
# 4337640720 4338970096 4338681984

t1[2][1]='pp'
print(id(t1[0]),id(t1[1]),id(t1[2]))
# 4337640720 4338970096 4338681984
# 如果元组中存在可变类型，是可以修改，但是修改后的内存地址不变

4）字典（可变）

dic={"name":"xxx","age":99,"gender":9}
print(id(dic))
# 4332807808


dic['age']=100
print(id(dic))
# 4332807808
# 对字典进行操作时，值改变的情况下，字典的id也是不变，即字典也是可变数据类型