Day05-循环和列表字符串、元组和字典

一、字符串

字符串就是由若干个不同的unicode字符组成的不可变序列

1 .字符串创建

#单引号字符串
str1 = '天要下雨，娘要嫁人，由他去吧'
str2 = str()  #空串
str3 = str([10,20,30])
​
#双引号字符串
str2 = "天要下雨，娘要嫁人，由他去吧"
​
#三引号字符串 多行字符串
str3 = '''
好雨知时节
当春乃发生
'''
str4 = """
随风潜入夜
润物细无声
""

2.获取字符

因为是不可变序列，所以不能修改单个字符；凡是修改字符串的操作都产生新串

str1 = '天要下雨，娘要嫁人，由他去吧'
print(str1[0],str1[-1]) #天 吧

3.字符串转义

• 常见转义字符

  转移字符	说明	转移字符	说明
  \'	单引号	\"	双引号
  \n	换行	\r	回车
  \t	tab	\\	\

• 原生字符

  如果在字符串中不把\当做转移字符，可以使用

  str1 = r'c:\wh1803\course\1'
  print(str1)  #c:\wh1803\course\1

4.序列通用操作

#1 字符串拼接
#对于字符串字面值，只要相邻两个字符串中间没有其他字符就会自动拼接为一个字符串
str1 = '中美达成共识'
        '不打贸易战'
print(str1) #中美达成共识不打贸易战
​
#其他情况使用+运算符拼接字符串
str1 = '你好'
str2 = ' 树先生'
print(str1 + '世界')
print(str1 + str2)
​
#2.字符串重复
str1 = '汪' * 3
print(str1) #汪汪汪
​
#3.成员操作
str1 = '天要下雨，娘要嫁人，由他去吧'
if '天' in str1:
    print('是成员')
else:
    print('不是成员')
​
#4.字符串截取（切片）
str1 = '123456'
print(str1[0:2]) #'12'
print(str1[1:]) #'23456'
print(str1[::2]) #'135'
print(str1[:]) #'123456'
print(str1[::-1]) #'654321'
​
#5.字符串长度
print(len(str1))

4 字符串常用函数

4.1 字符串查找和替换

str1 = 'a fox jumped over the fence'

方法名	说明	示例
str.count(sub,start=0,end=len(string))	查找子串sub出现的次数；start从指定下标开始查，end结束下标	str1.count('f')
str.find(str, beg=0, end=len(string))	从左向右检测字符串中是否包含子字符串 str,如果包含返回下标，否则返回-1。beg和end是可选参数，指定查找范围	str1.find('fox')
str.rfind(sub[, start[, end]])	从右向左检测字符串中是否包含sub子串，包含返回子串的下标，否则返回-1	str1.rfind('fox')
str.index(sub[, start[, end]])	作用类似find，但子串sub不存在会报错ValueError	str1.index('fox')
str.rindex(sub[, start[, end]])	从右向左检测，类似rfind，会报ValueError	str1.rindex('fox')
str.replace(old, new[, count])	返回一个新字符串，原串中的old被替换为new，可选参数count指定替换次数。	str1.replace('a','many')

4.2 字符串分隔和组合

方法名	说明	示例
str.split([sep[, num=count(sep)]])	将字符串拆分为以sep为分隔符的列表，如果指定num,则最多拆分num次	str1.split(' ')
str.rsplit([sep[, num=count(sep)]])	从右向左拆分
str.partition(seq)	将字符串拆分为一个有三个元素的元组（seq前的字符串，seq，seq后的字符串）。
str.rpartion(seq)	同上
str.splitlines([keepends])	拆分一个包含多行的字符串，以每行为一个元素返回一个列表。keepends是一个True字符或非零整数，表示保留行尾标志（即换行符）
str.join(seq)	以指定字符串str作为分隔符，将seq对象中所有的元素(字符串表示)合并为一个新的字符串;seq可以是字符串、列表等

4.3 字符串判断

方法	说明	示例
str.isalpha()	判断字符串是否由字母构成并且只包含字母，是返回True，否返回False	str1.isalpha()
str.isalnum()	检测字符串是否由字母和数字组成，如果都是数字或字母返回True，否则返回False
str.isdigit()	检测字符串是否由数字构成，可检测byte类型
str.isdecimal()	检测字符串是否由数字构成
str.isnumeric()	检测字符串是否由数字构成, 可以检测汉字数字：十
str.isspace()	检测字符串是否只有空格或tab构成
str.islower()	检测字符串中的字母字符是否全部由小写字母组成
str.isupper()	检测字符串中的字母字符是否全部由大写写字母组成
str.startswith(suffix[, start[, end]])	用于判断字符串是否以指定子字符串开头，如果是则返回True，否则返回False。
str.endswith(suffix[, start[, end]])	用于判断字符串是否以指定子字符串 结尾，如果是则返回True，否则返回False。

4. 4字符串转换

方法	说明	示例
str.lower()	字符串转小写
str.upper()	字符串转大写
str.swapcase()	把字符串中的大小写字母互换，大写转换成小写，小写转换成大写。不去管非字母类字符。
str.capitalize()	将字符串的第一个字符转换为大写， 其余转换为小写
str.title()	字符串中每个单词的首字母大写，其余小写。
str1.center(width,[fillchar])	用指定宽度居中显示字符串，如果字符串无法填满width，将用指定字符填充字符串，默认用空格填充	str1.center(80,'*')
str.ljust(width[, fillchar])	用指定宽度居左显示字符串
str.rjust(width[, fillchar])	用指定宽度居右显示字符串
str.lstrip([chars])	去除字符串左边指定的字符，默认是去除空格
str.rstrip([chars])	去除字符串左边指定的字符，默认是去除空格
str.strip([chars])	去除字符串两边边指定的字符，默认是去除空格

4.5 其它方法

#1. 将其他类型转换为字符串
print(str(90)) #'90'
print(str([20,30])) #'[20,30]'
​
#2 ord(x) 返回一个字符所对应的码值
print(ord('a')) #97
print(ord('中')) #20013
​
#3 chr(x) 输入一个unicode码，返回一个对应的字符。
print(chr(20013))  #中
​
#eval，将字符串当做代码执行
age = 1
print(eval('age + 3'))  # 4
print(eval('+123'))   #123
print(eval('3 + 2'))   #5
​
#有安全问题
eval("__import__('os').system('dir')") #显示当前目录的文件列表
​
#4 repr(x)  返回一个对象的String格式，适合机器执行
a = [20,30]
s1 = repr(a)
list1 = eval(s1)
list2 = str(a)
print(a == list1)
print(a == list2)

5. 字符串格式化

• 用%格式化

  %[flags][width][.precision]typecode
  flags:对其方式，-左对齐 +右对齐(默认),0表示用0填充，默认是用空格填充
  width：所占宽度，单位是列
  .precision: 精度，如果带小数点，可以指定带几位小数，指定后会四舍五入
  typecode: d 将数值转换为整型显示；f 将数值转换为浮点数显示 s将数值转换为字符串显示
  #大家好，我叫   王尼玛，我今年35岁了,我有5000000.69
  print("大家好，我叫%+6s，我今年%d岁了,我有%10.2f" % ('王尼玛',35,5000000.687))

• 用format格式化

  [[fill]align][sign][#][width][.precision][type]
  fill: 填充字符，可选
  align: 对齐方式  <左对齐  >右对齐  ^居中对齐
  sign：显示符号，+正数显示正号，负数显示符号；-正数不显示符号，负数显示符号
  #： 对于2、8、16进制会显示0b 0o 0x
  width: 宽度
  , 千分位分隔符
  .precision：精度
  type： s字符串  d整型  f浮点数
  ​
  tp1 = "I am {}, age {}, {}".format("seven", 18, 'alex')
  tp2 = "I am {name}, age {age}, really {name}".format(name="seven", age=18)
  tp3 = "I am {:s}, age {:d}, money {:.0f}".format("seven", 18, 88888.1)
  print(tp1) #I am seven, age 18, alex
  print(tp2) #I am seven, age 18, really seven
  print(tp3) #I am seven, age 18, money 88888

二、字节

在python3中最重要的特性是对文本和二进制数据做了更加清晰的区分，文本总是Unicode，由字符类型表示，而二进制数据则由byte类型表示，python3不会以任意隐式方式混用字节型和字符型，也因此在python3中不能拼接字符串和字节包（python2中可以，会自动进行转换），也不能在字节包中搜索字符串，也不能将字符串传入参数为字节包的函数。

Bytes 对象是由单个字节作为基本元素（8位，取值范围 0-255）组成的序列，为不可变对象。 bytes对象只负责以二进制字节序列的形式记录所需记录的对象，至于该对象到底表示什么（比如到底是什么字符）则由相应的编码格式解码所决定。Python3中，bytes通常用于网络数据传输、二进制图片和文件的保存等等。可以通过调用bytes()生成bytes实例，其值形式为 b'xxxxx'，其中 'xxxxx' 为一至多个转义的十六进制字符串（单个 x 的形式为：\x12，其中\x为小写的十六进制转义字符，12为二位十六进制数）组成的序列，每个十六进制数代表一个字节（八位二进制数，取值范围0-255），对于同一个字符串如果采用不同的编码方式生成bytes对象，就会形成不同的值.

1 创建字节

#创建字节
b1 = b'hello'
b2 = b"ello"
b3 = b'''hello'''
b4 = bytes('中文','utf-8')

2 设置python文件编码格式

# -*- coding: utf-8 -*-
import sys
sys.setdefaultencoding('utf-8') #修改系统默认编码格式

3 字符串和字节的转换

#字符串转字节
s1 = "中文"
s2 = s1.encode('utf-8')  #str.encode()
print(type(s2))  #<class 'bytes'>
print(s2)  #b'\xe4\xb8\xad\xe6\x96\x87'
​
#字节转字符串
s3 = s2.decode('utf-8')  #bytes.decode()
print(type(s3))  #<class 'str'>
print(s3)  #中文

三、元组

元组和列表相似，但元组属于不可变序列，所以元组：

• 不能修改元素的值

• 元组用（）表示

1.1 创建元组

t1 = ()   #创建一个空元组
#或者
t1 = tuple() #空元组
​
t2 = (1,) #创建带有一个元素的元组，后面的逗号是必须的，否则无法区分是（）表达式还是元组
或者：t2 = 1,
t3 = (1,4,True,'hello')
t4 = 10,20,30 #t4 = (10,20,30)
t5 = tuple('abc')

1.2 成员访问

t1 = (10,7,12,23)
print(t1[0])
#print(t1[4]) 下标越界 IndexError
​
t2 = (1,2,[4,5])
t2[2][0] = 10  #元组的元素无法修改，但元素如果是可变列表，则列表元素是可以修改的

1.3 通用操作

#1.连接
t1 = (1,2,3)
t2 = (4,5,6)
t3 = t1 + t2
print(t3)  #(1,2,3,4,5,6)
​
#2.重复
print(t1 * 2)  #(1,2,3,1,2,3)
​
#3.切片
print(t3[0:3])  #(1,2,3)
print(t3[3:])   #(4,5,6)
print(t3[-1::-1]) (6,5,4,3,2,1)
​
#4.成员运算符
print(3 in t3)  #True
print(2 not in t3) #False
​
#5.元素个数
print(len(t3))
​
#6.最值
print(max(t3))  #6
print(min(t3))  #1

1.4 元组其它操作

• 元组和列表的转换

  t1 = (10,20,30)
  l1 = [1,2,3]
  ​
  #列表转元组
  print(tuple(l1))
  ​
  #元组转列表
  print(list(t1))

• 查找

  t1 = (10,20,30,10)
  print(t1.index(20))  #查找值等于20的第一个元素
  print(t1.count(10))  #返回元组中10的个数

• 遍历

  t1 = (10,20,30,10)
  for value in t1:
      print(value)
      
  #同时获取下标和值
  for index,value in enumerate(t1):
      print(index, value)
  ​
  #通过下标遍历
  for i in range(len(t1)):
      print(t1[i])

  1.5 二维元组

t1 = ((1,2,3),(4,5,6))
​
#遍历
for elem in t1:
    for value in elem:
        print(value, end = ' ')
    print('')

1.6 序列的解包

#元组解包
#变量个数和元素个数一致
t1 = (11,20)
a, b = t1
print(a,b)  #11 20
​
a, b = 2, 3  
a,b,c = (1,2,3) 
​
#变量个数和元素个数不同
#a=10,c=50,_获取（20,30）
a, *_, c = 10,20,30,50
print(a,c,_) #10 50 [20, 30]
​
#a=10，b=20,c获得剩余的元素
a, b, *c = 10,20,30,50
print(a,b,c) #10 20 [30, 50]
​
#*解包
print(*(1,2,3))  # 1 2 3
​
#range解包
a, b, c = range(3)  #a=0,b=1,c=2
​
#列表解包
a,*_b,c = [1,2,3,4,5]
print(a,_b,c) # 1 [2, 3, 4] 5
​
#字符串解包
a,b,c = '123'
print(a,b,c) # a='1',b='2',c='3'
​
​
# *解包形式
a = (1,2,3,4)
print(*a)
print(*[1,2,3,4])

###

四、字典

字典不属于序列，元素存放无序，是通过哈希方式进行数据存取的，字典是一个可变容器，字典中保存一个个的键值对： key : value。我们通过key来获取对应的值，很类似我们的汉语字典。

• 字典中键必须是唯一的，必须是不可变类型

• 字典查找速度比较快

2.1 字典的创建

d1 = {}  #空字典
d1 = dict()  #空字典
d2 = {'name':'麻辣龙虾','taste':'美味'}
d3 = dict(a=1,b=2)
d4 = dict([('a', 1),('b', 2)])
d5 = dict({'a':1,'b':2})

2.2 字典操作

#存储多个学生的成绩
dict1 = {"jack":78,"hanmeimei":99,"lilei":60}
print(dict1)
​
#1.元素访问
#获取   语法：字典名[key]
print(dict1["hanmeimei"])
​
#print(dict1["tom"]) #KeyError: 'tom'
​
#字典名.get()
result = dict1.get("lilei",'1')  # 如果没有lilei这个键，返回默认值1，不会报错
print(result)
​
#2.添加:当指定的键不存在的时候，则表示添加
dict1["tom"]  = 70
print(dict1)
#但是，如果键已经存在，则表示修改value
dict1["jack"]  = 50
print(dict1)
​
#3. 删除 pop 删除并返回指定键对应的值
#注意：通过键，直接删除整个键值对
dict1.pop("jack")
print(dict1)
​
del dict1['lilei'] #删除键值对，不返回值
dict1.clear()  #清空字典
del dict1  #删除整个字典
​
#4 字典合并
a = {1:'hello'}
b = {2:'world'}
a.update(b)
print(a)
​
#5.遍历
dict2 = {"jack":78,"hanmeimei":99,"lilei":60}
​
#方式一：只获取键
for key in dict2:
    value = dict2[key]
    print(key,value)
​
#方式二：只获取值
#values,得到的结果是一个列表，当做列表处理
print(dict2.values())
​
for value in dict2.values():
    print(value)
​
​
#方式三：同时获取键和值
#items,得到的结果是一个列表，列表中的元素是元组
print(dict2.items())  #[('jack', 78), ('hanmeimei', 99), ('lilei', 60)]
​
for key,value  in dict2.items():
    print(key,value)
​
#方式四
for index,key in enumerate(dict2):
    value = dict2[key]
    print(index,key,value)
​
#6.获取键值对的个数
print(len(dict1))
​
#7.成员操作
d2 = {'name':'麻辣龙虾','taste':'美味'}
print('name' in d2) #判断某个键是否在列表中