Python(四)

1.字符串类型

1.按索引取值(正向取+反向取):只能取
str = 'hello world'
# 正向取
print(str[0])
# 反向取
print(str[-1])

# 只能取,不能改

2.切片:索引的拓展应用，从一个大字符串中拷贝出一个子字符串(顾头不顾尾，步长)
str = 'hello world'
res = str[0:5]
print(res)
print(str)

# 步长
res = str[0:5:2]
print(res)
# 反向步长
res = str[5:0:-1]
print(res)

# 长度len
print(len(str))

# 成员运算in和not in
# 判断一个子字符串是否存在于一个大字符穿
print('alex' in 'alex' is 'sb')
print(not 'alex' in "alex is sb")  # 不推荐使用
print('alex' not in "alex is sb")

# 移除空白strip
str = '        egon     '
res = str.strip()  # 默认去掉的空格
print(res)
str = '@@@@@@@@@egon***************'    # 去掉左右两侧的@和*
print(str.strip('@,*'))

# 切分split:把一个字符串按照某种分隔符进行切分，得到一个列表
info = 'egon 18 male'
print(info.split()) # 默认分隔符是空格

info = 'egon:18:male'
print(info.split(':'))  # 指定分隔符

# 指定分隔次数(了解）
info = 'egon:18:male'
print(info.split(':',1))

# 循环
info = 'egon:18:male'
for x in info:
    print(x)
需要掌握:
# 1.strip lstrip rstrip
str = '*****egon**********'
print(str.strip('*'))
print(str.lstrip('*'))
print(str.rstrip('*'))
# 2.lower,upper
str = 'AAADDDFRFRFR'
print(str.lower())
print(str.upper())
# 3.startwith, endswith
print("alex is sb".startswith('alex'))
print("alex is sb".endswith('sb'))
# 4.format的三种玩法

# 5.split, rsplit
info = "egon:18:male"
print(info.split(':', 1))
print(info.rsplit(':', 1))
# 6.join:把列表拼接成字符串
l = ['egon', '18', 'male']
print(l[0] + ":" + l[1] + ":" + l[2])
print(":".join(l))  # 按照某个分隔符号，把元素全为字符串的列表拼接成一个大字符串

# 7.replace
str = "you can you np no can no bb"
print(str.replace("you", "YOU", 1))

# 8.isdigit
# 判断字符串是否由纯数字组成
print('123'.isdigit())
print("12.3".isdigit())

age = input("请输入你的年龄：").strip()
if age.isdigit():
    age = int(age)
    if age > 18:
        print("猜大了")
    elif age < 18:
        print("猜小了")
    else:
        print('猜小了')
else:
    print("必须输入数字")

2.队列堆栈

队列：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))
# 堆栈：LIFO，后进先出
# 入栈操作
l.append('first')
l.append('second')
l.append('third')
# 出栈操作
print(l.pop())
print(l.pop())
print(l.pop())

3.元组

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

tuple = (1, 1.3, 6, 99, 'shun')
print(tuple,type(tuple))
# 类型转换
print(tuple('hello'))
print(tuple([1, 2, 3]))
print(tuple({'a1': 111, 'a2': 222}))

# 内置方法
tuple = (1, 2, 9)
print(tuple.count(1))
print(tuple.index(1))
# 1.按索引取值(正向取+反向取)
tuple = ('aa', 'bbb', 'ccc')
print(tuple[0])
print(tuple[-1])

# 2.切片
tuple = ('aaa', "dd+1", 'python', '2387')
print(tuple[0:3])
print(tuple[::-1])
# 3.长度
print(len(tuple))

# 4.成员运算in和not in
print('aaa' in tuple)

# 5.循环
for x in tuple:
    print(x)

4.集合类型

作用：集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算
定义：
"""
定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：
     1：每个元素必须是不可变类型
     2：集合内没有重复的元素
     3：集合内元素无序
"""
s = {1,2,3,4}  # 本质 s = set({1,2,3,4})

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

# 注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式，现在我们想定义一个空字典和空集合，该如何准确去定义两者?
d = {} # 默认是空字典 
s = set() # 这才是定义空集合

类型转换：
# 但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型
>>> s = set([1,2,3,4])
>>> s1 = set((1,2,3,4))
>>> s2 = set({'name':'jason',})
>>> s3 = set('egon')
>>> s,s1,s2,s3
{1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'e', 'o', 'g', 'n'}

4.1关系运算

# 1.关系运算
friends1 = {"zero","kevin","jason","egon"} # 用户1的好友们
friends2 = {"Jy","ricky","jason","egon"}   # 用户2的好友们
l = []
for x in friends1:
    if x in friends2:
        l.append(x)
print(l)

4.2 内置方法

friends1 = {"zero","kevin","jason","egon"} # 用户1的好友们
friends2 = {"Jy","ricky","jason","egon"}   # 用户2的好友们
# 1.取交集
print(friends1 & friends2)
print(friends1.intersection(friends2))
# 2.取并集/合集：
print(friends1 | friends2)
print(friends1.union(friends2))
# 3.取差集：取friend1独有的
print(friends1 - friends2)
print(friends1.difference(friends2))
# 取friend2独有
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}
print(s1 > s2)  # 不存在包含关系，输出为False

s1 = {1, 2, 3}
s2 = {1, 2}
print(s1 > s2)  # 当s1大于或等于s2时，才能说s1是s2他爹
print(s1.issuperset(s2))
print(s2.issubset(s1)) # s2 < s1 =》 Ture
s1 = {1, 2, 3}
s2 = {1, 2, 3}
print(s1 == s2) # s1与s2互为父子
print(s1.issuperset(s2))
print(s2.issuperset(s1))

4.3去重

集合去重复有局限性

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

# 1.只能针对不可变量类型去重
print(set([111, 1, 1, 1111, 2, 6666]))
# 2.无法保证原来的顺序
l = [1, 'a', 'b', 'z', 1111, 5]
print(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)

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

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

# 了解
s.difference_update({3, 4, 5})  # s= s.difference({3, 4, 5}) # 求差集并赋值
print(s)

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