Python开发【第二章】：补充

一.字符串方法讲解：

#---------字符串各种方法----------
s = "Hello world!"

#1.swapcase():大小写互换
print(s.swapcase())
#输出：hELLO WORLD!

#2.capitalize():返回第一个字符为大写，其他字符为小写
#源码：
'''
Return a capitalized version of S, i.e. make the first character
        have upper case and the rest lower case.
'''
print(s.capitalize())
#输出：Hello world!

#3.casefold():返回所有字符为小写
#源码：
'''
Return a version of S suitable for caseless comparisons.
'''
print(s.casefold())
#输出：hello world!

#4.center():参数为一个数字和一个字符，在这个数字为长度的范围内，字符串居中，两边由那个字符补足
print(s.center(50,'#'))
#输出：###################Hello world!###################

#5.count():统计字符串中某个字符的个数，也可以从一个范围开始
#如：print(s.count('o',0,5))  输出为1
print(s.count('o'))
#输出：2

#6.endswith():判断字符串以什么结尾
print(s.endswith('d!'))
#输出：True

#7.expandtabs():扩展tab键
s2 = 'a	b'    #	就是tab键
print(s2.expandtabs())
#输出：a       b    #tab键默认8个空格
print(s2.expandtabs(20))   #tab键可以指定空格
#输出：a                   b

#8.find():返回字符在字符串中的位置，没有则返回-1;也可以从一个范围开始
#如：print(s.find('o',0,3))  输出：-1
print(s.find('o'))
#输出：4
print(s.find('sdaf'))
#输出：-1

#9.format()：字符串格式化输出
#方法一：
s3 = 'my name is {0},i am {1} years old'
print(s3.format('Mm',18))
#输出：my name is Mm,i am 18 years old

#方法二：
s4 = 'my name is {name},i am {age} years old'
print(s4.format(name = 'Mm',age = 18))
#输出：my name is Mm,i am 18 years old

#10.isalnum():是否为阿拉伯数字或字符
print('22'.isalnum())
#输出：True

#11.isalpha():是否为字符
print('mm'.isalpha())
#输出：True

#12.isdecimal():是否是个数字

#13.isdigit()：是否是个数字

#14.isidentifier():是否是个合法的变量名

#15.islower():是否都是小写

#16.isnumeric():是否都是数字

#17.isprintable():是否是可打印的(文本文件或者是字节型文件)

#18.issapce():判断是否是空格
print(' '.isspace())
#输出：True

#19.istitle():判断是不是标题

#20.isupper()：判断是不是都是大写

#21.join():列表元素以一种方式，如下例中的'*'连接成字符串
names = ['mm','mumu','tt']
print('*'.join(names))
#输出：mm*mumu*tt

#22.ljust():右填充
print(s.ljust(50,'*'))
#输出：Hello world!**************************************

#23.rjust():左填充
print(s.rjust(50,'#'))
#输出：######################################Hello world!

#24.lower():将字符串改成小写
print(s.lower())
#输出：hello world!

#25.upper():将字符串改成大写
print(s.upper())
#输出：HELLO WORLD!

#26.strip():去掉空格或换行

#27.lstrip():只去掉左边空格或换行

#28.rstrip():只去掉右边空格或换行

#29.maketrans():生成对应表
#30.translate():翻译
str_in = 'abcdef'
str_out = '!@#$%^'

table = str.maketrans(str_in,str_out)

print(table)
#输出：{97: 33, 98: 64, 99: 35, 100: 36, 101: 37, 102: 94}

print(s.translate(table))
#输出：H%llo worl$!

#31.partition():一个字符串以其中的字符分割成三段
print(s.partition('o'))
#输出：('Hell', 'o', ' world!')

#32.rpartition():一个字符串以其中的字符分割成三段，从右边开始寻找
print(s.rpartition('o'))
#输出：('Hello w', 'o', 'rld!')

#33.replace():替换，不指定一个数字将全部换掉
print(s.replace('o','*',1))
#输出：Hell* world!

#34.rfind():从右边开始找,找不到的时候为-1
print(s.rfind('l'))
#输出：9

#34.rindex():从右边找，当找不到的时候报错

#35.split(): 默认以空格来分割字符串为列表
print(s.split())
#输出：['Hello', 'world!']

#36.rsplit():从右边开始分
#如：
print(s.split('o',1))
print(s.rsplit('o',1))
#输出：
# ['Hell', ' world!']
# ['Hello w', 'rld!']

#37.splitlines():按行来分
t = 'a
b
mm
c'
print(t.splitlines())
#输出：['a', 'b', 'mm', 'c']

#38.startswith():判断以什么开始
print(s.startswith('He'))
#输出：True

#39.zfill():字符串变成一个长度的，不够用0填充
print(s.zfill(40))
#输出：0000000000000000000000000000Hello world!

二.元组类型：

  (1)特性：
     1.不可变
     2.元组本身不可变，如果元组中包含其他可变元素,这些可变元素可以改变

  (2)功能：
     1.index
     2.count
     3.切片

  (3)使用场景：
     1.显示的告知别人，此处数据不可修改
     2.数据库连接配置信息等

三.hash函数：

  (1)定义：将任意长度的消息压缩到某一固定长度的消息摘要的函数

  (2)特征：     hash值的计算过程是依据这个值的一些特征计算的，这就是要求hash的值必须固定，因此被hash的值必须是不可变的。

  (3)用途：
     1.文件签名
     2.md5加密
     3.密码验证

四.字典类型：

  (1)特性：
     1.key-value结构
     2.key必须可hash，且必须为不可变数据类型，必须唯一
     3.可存放任意多个值，可修改，可以不唯一
     4.无序
     5.查找速度快（key转换成hash数字，然后排序，通过二分法来查找，最多2的多少次幂,但是hash不是这种方法，但是更快）

  (2)方法：

info = {
    'stu001':'mm',
    'stu002':'tt',
    'stu003':'mumu'
}

方法：
#1.clear():清空字典

#2.copy()：类似于列表的深浅copy

#3.values():
print(info.values())
#输出：dict_values(['mm', 'tt', 'mumu'])

#4.keys():
print(info.keys())
#输出：dict_keys(['stu001', 'stu002', 'stu003'])

#5.items():
print(info.items())
#输出：dict_items([('stu001', 'mm'), ('stu002', 'tt'), ('stu003', 'mumu')])

#6.updates():两个字典组合起来，当有相同的key时，更新的value会替换掉原有的value
dic1 = {1:2,2:3,'stu003':['mumu','small dog']}
info.update(dic1)
print(info)
#输出：{'stu001': 'mm', 'stu002': 'tt', 'stu003': ['mumu', 'small dog'], 1: 2, 2: 3}

#7.setdefault():输入的key如果字典中有，则不更新，如果没有，则创建
info.setdefault('test','new')

#8.fromkeys():批量创造字典元素

#9.循环：
for k in info:
     print(k,info[k])
#输出：
# stu001 mm
# stu002 tt
# stu003 ['mumu', 'small dog']
# 1 2
# 2 3
# test new

for k,v in info.items():  #相对低效，有一个字典转换成列表的过程
    print(k,v)
#输出：
# stu001 mm
# stu002 tt
# stu003 ['mumu', 'small dog']
# 1 2
# 2 3
# test new

(3)习题：

#写代码，有如下字典，按照要求实现每一个功能：dic = {'k1':'v1','k2':'v2','k3':'v3'}

#1.请循环遍历出所有的 key
dic = {'k1':'v1','k2':'v2','k3':'v3'}
for k in dic:
    print(k)
# k1
# k2
# k3

#2.请循环遍历出所有的 value
for k in dic:
    print(dic[k])
# v1
# v2
# v3

#3.请循环遍历出所有的 key 和 value
for k in dic:
    print(k,dic[k])
# k1 v1
# k2 v2
# k3 v3

#4.请在字典中添加一个键值对，'k4':'v4'，输出添加后的字典
dic['k4'] = 'v4'
print(dic)
#输出：{'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'k4': 'v4'}

#5.请删除字典中键值对 'k1':'v1'，并输出删除后的字典
dic.pop('k1')
#或者
#del dic['k1']
print(dic)

#输出：{'k2': 'v2', 'k3': 'v3', 'k4': 'v4'}

#6.请删除字典中的键'k5'对应的键值对，如果字典中不存在键'k5'，则不报错，并且让其返回 None

# for k in dic:
#     if dic.get('k5'):
#         dic.pop('k5')
#         print(dic)
#     else:
#         print(dic.get('k5'))
# # None
# # None
# # None
# #返回3个none,在检查考虑一下

if dic.get('k5'):
    dic.pop('k5')
    print(dic)
else:
    print(dic.get('k5'))
#输出：None

#7.请获取字典中'k2'对应的值
print(dic['k2'])
#输出：v2

#8.请获取字典中'k6'对应的值，如果键'k6'不存在，则不报错，并且让其返回 None
print(dic.get('k6'))
#输出：None

#9.现有 dic2 = {'k1':'v111','a':'b'}通过一行操作使 dic2 = {'k1':'v1','k2':'v2','k3':'v3','a':'b'}
dic2 = {'k1':'v111','a':'b'}
dic2.update({'k1':'v1','k2':'v2','k3':'v3'})
print(dic2)
#输出：{'k1': 'v1', 'a': 'b', 'k2': 'v2', 'k3': 'v3'}

#10.组合嵌套题，学代码，有如下列表，按照要求实现每一个功能
lis = [['k',['qwe',20,{'k1':['tt',3,'1']},89],'ab']]
#a.将列表lis中的'tt'变成大写（用两种方式）
# lis[0][1][2].get('k1')[0] = 'TT'
# print(lis)
# #输出：[['k', ['qwe', 20, {'k1': ['TT', 3, '1']}, 89], 'ab']]
print(lis[0][1][2].get('k1')[0].upper())
print(lis[0][1][2].get('k1')[0].swapcase())
# TT
# TT

#b.将列表中的数字 3 变成字符串 '100'(用两种方式)
lis[0][1][2].get('k1')[1] = '100'
print(lis)
#输出：[['k', ['qwe', 20, {'k1': ['tt', '100', '1']}, 89], 'ab']]

dic3 = {'k1': ['tt', '100', '1']}
lis[0][1][2].update(dic3)
print(lis)
#输出：[['k', ['qwe', 20, {'k1': ['tt', '100', '1']}, 89], 'ab']]

#c.将列表中的字符串'1'变成数字101（用两种方式）
lis[0][1][2].get('k1')[2] = 101
print(lis)
#输出：[['k', ['qwe', 20, {'k1': ['tt', '100', 101]}, 89], 'ab']]

dic4 = {'k1': ['tt', '100', 101]}
lis[0][1][2].update(dic4)
print(lis)
#输出：[['k', ['qwe', 20, {'k1': ['tt', '100', 101]}, 89], 'ab']]

#11 按照要求实现以下功能：

#现有一个列表li = [1,2,3,'a','b',4,'c']，有一个字典（此字典是动态生成的，你并不知道他里面有多少键值对，所以

#用dic = {}模拟此字典）；现在需要完成这样的操作：如果该字典没有'k1'这个键，那就创建'k1'键和其对应的值(该键对应的值设置为空列表）

#并将列表li 中的 索引为奇数的对应元素，添加到'k1'这个键对应的空列表中。如果该字典有'k1'这个键，且'k1'对应的value

#是列表类型，那就将li中的索引为奇数的对应元素，添加到'k1'这个键对应的键中

li = [1,2,3,'a','b',4,'c']

dic = {}

if not 'k1' in dic:
    dic['k1'] = []
    for i in li:
        if li.index(i) %2 == 1:
            dic['k1'].append(i)
else:
    if type(dic['k1']) == type([]):
        for i in li:
            if li.index(i) %2 == 1:
                dic['k1'].append(i)
    print("字典k1，value不是列表，无法追加！")

print(dic)

五.集合类型：

 (1) 集合是一个无序的，不重复的数据组合，它的主要作用如下：
     1.去重，把一个列表变成集合，就自动去重了
     2.关系测试，测试两组数据之前的交集，差集，并集的关系

(2)方法：

#1.去重：
s = {1,2,3,4,2,3,7}
print(s)
#输出：{1, 2, 3, 4, 7}

#2.可将列表和元组转换成集合
l = [2,3,4,3,4,5]
s1 = set(l)
print(s1)
#输出：{2, 3, 4, 5}

#3.add:增加
s.add(6)
print(s)
#输出：{1, 2, 3, 4, 6, 7}

#4.pop:随机删除
s.pop()
print(s)
#输出：{2, 3, 4, 6, 7}

#5.remove：删除，不存在会报错
s.remove(7)
print(s)
#输出：{2, 3, 4, 6}

#6.discard：删除,不存在不报错

#7.update:两个集合联合

#8.clear:清除

  (3)集合关系测试:

#1.交集：intersection和&
iphone7 = {'tt','mm','zz'}
iphone8 = {'mm','zz','mumu'}

print(iphone7.intersection(iphone8))
#输出：{'mm', 'zz'}
print(iphone7 & iphone8)
#输出：{'mm', 'zz'}

#2.差集：difference和-
print(iphone7.difference(iphone8))
#输出：{'tt'}
print(iphone7 - iphone8)
#输出：{'tt'}

#3.并集：union 和 |
print(iphone7.union(iphone8))
#输出：{'zz', 'tt', 'mumu', 'mm'}
print(iphone7 | iphone8)
#输出：{'zz', 'tt', 'mumu', 'mm'}

#4.对称差集：symmetric_difference和^
s2 = {1,2,3,4}
s3 = {2,3,5,6}
print((s2|s3)-(s2&s3))
#输出：{1, 4, 5, 6}

print(s2.symmetric_difference(s3))
#输出：{1, 4, 5, 6}
print(s2^s3)
#输出：{1, 4, 5, 6}

#5.issubset：判断是否为子集 <=
s3.add(1)
s3.add(4)
print(s3)
#输出：{1, 2, 3, 4, 5, 6}
print(s2.issubset(s3))
#输出：True

#6.issuperset:判断是否为父集  >=
print(s3.issuperset(s2))
#输出：True

#7.isdisjoint:判断两个集合是不是不相交

#8.s2.difference_update(s3):将两者的差集赋值给s2