Python ☞ day 3

Python学习笔记之 字符串 & 列表 & 元组 & 字典

字符串

什么是字符串？

字符串是以单引号或双引号括起来的任意文本
'abc'   "def"
字符串不可变

创建字符串
str1 = "lee is a good man!"
str2 = "lee is a nice man!"
str3 = "lee is a handsome man!"

字符串运算

字符串连接
str6 = "lee is a "
str7 = "good man"
str8 = str6 + str7
print("str6 =", str6)
print("str7 =", str7)
print("str8 =", str8)

输出重复字符串
str9 = "good"
str10 = str9 * 3
print("str10 =", str10)

访问字符串中的某一个字符
通过索引下标查找字符
字符串名[下标]
str11 = "lee is a good man!"
print(str11[1])
#str11[1] = "a" #打印会报错，因为字符串不可变
#print("str11 =", str11)

截取字符串中的一部分
str12 = "lee is a good man!"
print(str12[4:14])  #从给定下标开始截取到给定下标之前
print(str12[:4])    #从头截取到给定下标之前
print(str12[14:])   #从给定下标处开始截取到结尾

判断
str13 = "lee is a good man!"
print("good" in str13)
print("good" not in str13)

格式化输出
print("lee is a good man")
num = 10
str14 = "lee is a nice man!"
f = 10.14567
print("num =", num)
#      %d       %s      %f      占位符
#                                 %.2f 精确到小数后2位，会四舍五入
print("num = %d, str14 = %s, f = %.2f" %(num,str14,f))

字符串方法

#   eval(str)
#   功能：将字符串str当成有效的表达式来求值并返回计算结果
print(eval("+123"))
print(eval("-123"))
print(eval("12+3"))
print(eval("12-3"))

#   len(str)
#   返回字符串的长度(字符个数)
print(len("lee is a good man!"))

#   lower()
#   转换字符串中大写字母为小写字母
str15 = "LEE is a Good Man!"
print(str15.lower())

#   upper()
#   转换字符串中小写字母为大写字母
str16 = "LEE is a Good Man!"
print(str16.upper())
print("LEE is a Good Man!".upper())

#   swapcase()
#   转换字符串中大写字母为小写字母，小写字母为大写字母
str17 = "LEE is a Good Man!"
print(str17.swapcase())

#   capitalize()
#   首字母大写，其他小写
str18 = "LEE is a Good Man!"
print(str18.capitalize())

#   title()
#   每个单词的首字母大写
str19 = "LEE is a Good Man!"
print(str19.title())

#   center(width[,fillchar])
#   返回一个指定宽度的居中字符串，fillchar为填充的字符串,默认是空格填充
str20 = "lee is a nice man!"
print(str20.center(40,"*"))

#   ljust(width[,fillchar])
#   返回一个指定宽度的左对齐字符串，fillchar为填充的字符串,默认是空格填充
str21 = "lee is a nice man!"
print(str21.ljust(40,"%"))

#   rjust(width[,fillchar])
#   返回一个指定宽度的右对齐字符串，fillchar为填充的字符串,默认是空格填充
str22 = "lee is a nice man!"
print(str22.rjust(40,"%"))

#   zfill(width)
#   返回一个长度为width的字符串，原字符串右对齐，前面补0
str23 = "lee is a nice man!"
print(str23.zfill(40))

#   count(str[,start][,end])
#   返回字符串中strc出现的次数，可以指定一个范围，默认从头到尾
str24 = "lee is a very very nice man!"
print(str24.count("very"))
print(str24.count("very",9,len(str24)))

#   find(str[,start][,end])
#   从左向右检测str字符串是否包含在字符串中，可以指定范围，默认从头到尾，得到的是第一次出现的开始下标，没有返回-1
str25 = "lee is a very very nice man!"
print(str25.find("very"))
print(str25.find("good"))
print(str25.find("very",8,len(str25)))

#   rfind(str[,start][,end])
str25 = "lee is a very very nice man!"
print(str25.rfind("very"))
print(str25.rfind("good"))
print(str25.rfind("very",8,len(str25)))

#   index(str,start=0,end=len(str))
#   跟find()一样，只不过如果str不存在的时候会报一个异常
str26 = "lee is a very very nice man!"
print(str26.index("very"))

#   rndex(str,start=0,end=len(str))
#   跟rfind()一样，只不过如果str不存在的时候会报一个异常
str27 = "lee is a very very nice man!"
print(str27.rindex("very"))

#   lstrip()
#   截掉字符串左侧指定的字符，默认为空格
str28 = "*******lee is a nice man!"
print(str28.lstrip("*"))

#   rstrip()
#   截掉字符串右侧指定的字符，默认为空格
str29 = "lee is a nice man!       "
print(str29.rstrip(),"*")

#   strip()
#   截掉字符串两侧指定的字符，默认为空格
str30 = "******lee is a nice man******"
print(str30.strip("*"))

#  split(str="",num)
#  以str为分隔符截取字符串,指定num，则仅截取num个字符串
str31 = "lee***is*****a**good**man"
print(str31.split("*"))
list39 = str31.split("*")
c = 0
for s in list39:
    if len(s) > 0:
        c += 1
print(c)

#  splitlines([keepends])
#  按照('\r', '\r\n', '\n')分割
#  keepends == True  会保留换行符
str32 = '''
lee is a good man!
lee is a nice man!
lee is a handsome man!
'''
print(str32.splitlines())

#   join(seq)
#以指定的字符串分隔符，将seq中的所有元素组合成一个字符串
list33 = ['lee','is','a','good','man']
str33 = " ".join(list33)
print(str33)

#   max() min()
str34 = "lee is a good man z"
print(max(str34))
print("*"+min(str34)+"*")

#   replace(oldstr,newstr,count)
#   用newstr替换oldstr，默认是全部替换。如果指定了count，那么只替换前count个
str35 = "lee is a good good good man"
str36 = str35.replace("good","nice",1)
print(str36)

#   创建一个字符串映射表
#                      要转换的字符串， 目标字符串
str37 = str.maketrans("ac","65")
#   a--6    c--5
str38 = "lee is a good man"
str39 = str38.translate(str37)
print(str39)

#   startswith(str,start=0,end=len(str))
#   在给定的范围内是否是以给定的字符串开头的，如果没有指定范围，默认整个字符串
str40 = "lee is a good man"
print(str40.startswith("lee",5,14))

#   endswith(str,start=0,end=len(str))
#   在给定的范围内是否是以给定的字符串结尾的，如果没有指定范围，默认整个字符串
str41 = "lee is a good man"
print(str41.endswith("man"))

#   编码
#encode(encoding="utf-8",errors="strict")
str42 = "lee is a good man杰"
#ignore 忽略错误
date42 = str42.encode("utf-8","ignore")
print(date42)

#   解码 注意：要与编码时的编码格式一致
str43 = date42.decode("gbk","ignore")
print(str43)

#   isalpha()
#   如果字符串中至少有一个字符且所有的字符都是字母返回True，否则返回False
str44 = "leeisagoodman"
print(str44.isalpha())

#   isalnum()
#   如果字符串中至少有一个字符且所有的字符都是字母或数字返回True，否则返回False
str45 = "12a3"
print(str45.isalnum())

#   isupper()
#   如果字符串中至少有一个英文字符且所有的字符都是大写的英文字母返回True，否则返回False
print("ABD".isupper())
print("AbC".isupper())
print("ABC".isupper())
print("ABD#".isupper())

#   islower()
#   如果字符串中至少有一个英文字符且所有的字符都是小写的英文字母返回True，否则返回False
print("abc".islower())
print("Abcd".islower())
print("ABCD".islower())
print("abc1".islower())
print("abc!".islower())

#   istitle()
#   如果字符串是标题化的返回True，否则返回False
print("Lee Is".istitle())
print("Lee is".istitle())
print("lee is".istitle())

#   isdigit()
#   如果字符串只包含数字字符返回True，否则返回False
print("123".isdigit())
print("123a".isdigit())

#   isnumeric()
#   同上
print("123".isnumeric())
print("123s".isnumeric())

#   isdecimal()
#   字符串中只包含十进制字符
print("123".isdecimal())
print("123a".isdecimal())

#   如果字符串中只包含空格返回True，否则返回False
print(" ".isspace())
print("   ".isspace())
print("\t".isspace())
print("\n".isspace())
print("\r".isspace())

列表

列表 本质：是一种有序的集合
创建列表
格式：列表名 = [列表选项1,列表选项2, ......,列表选项n]

#创建一个空列表
list1 = []
print(list1)

#创建带有元素的列表
list2 = [18, 19, 20, 21, 22]
index = 0
sum = 0
#嵌套最好不要超过3层
while index < 5:
    sum += list2[index]
    index += 1
    if index == 5:
        print("平均年龄：%d" %(sum / 5))
#注意：列表中的元素数据可以是不同类型的
list3 = [1, 2, 3, "lee", "good", True]
print(list3)

#列表元素的访问
#注意不要越界（下标超出了可表示的范围）
#取值 格式：列表名[下标]
list4 = [1, 2, 3, 4, 5]
print(list4[2])

#替换
list4[2] = 300
print(list4)

列表操作：

#列表组合
list5 = [1,2,3]
list6 = [4,5,6]
list7 = list5 + list6
print(list7)

#列表的重复
list8 = [1,2,3]
print(list8 * 3)

#判断元素是否在列表中
list9 = [1,2,3,4,5]
print(3 in list9)
print(6 in list9)

#列表截取
list10 = [1,2,3,4,5,6,7,8,9]
print(list10[2:5])
print(list10[3:])
print(list10[:5])

#二位列表
list11 = [[1,2,3],[4,5,6],[7,8,9]]
print(list11[0][1])

列表方法

#   在列表的末尾添加新的元素
list12 = [1,2,3,4,5]
list12.append(6)
list12.append([7,8,9])
print(list12)

#   在末尾一次性追加另一个列表中的多个值
list13 = [1,2,3,4,5]
list13.extend([6,7,8])
print(list13)

#   在下标处添加一个元素，不覆盖原数据，原数据向后顺延
list14 = [1,2,3,4,5]
list14.insert(3,100)
list14.insert(3,[44,22])
print(list14)

#   pop(x=list[-1])
#   移除列表中指定下标处的元素（默认移除最后一个元素）,并返回删除的数据
list15 = [1,2,3,4,5]
list15.pop()
list15.pop(2)
print(list15.pop(1))
print(list15)

#   remove 移除列表中的某个元素第一个匹配的结果
list16 = [1,2,3,4,5,6,3,4,2]
list16.remove(4)
print(list16)

#   清除列表中所有的数据
list17 = [1,2,3,4,5]
list17.clear()
print(list17)

#   从列表中找出某个值第一个匹配的索引值
list18 = [1,2,3,4,5,3]
index18 = list18.index(3)
index19 = list18.index(3,3,6)
print(index18)
print(index19)

#   列表中元素的个数
list20 = [1,2,3,4,5]
print(len(list20))

#   获取列表中的最大值
list21 = [1,2,3,4,5]
print(max(list21)

#   获取列表中的最小值
list22 = [1,2,3,4,5]
print(min(list22))

#   查看元素在列表中出现的次数
list23 = [1,2,3,4,5,3,4,5,4,3,2]
print(list23.count(3))

num24 = 0
all = list23.count(3)
while num24 < all:
    list23.remove(3)
    num24 += 1
print(list23)

#   倒序
list25 = [1,2,3,4,5]
list25.reverse()
print(list25)

#   升序排序
list26 = [2,3,4,1,5]
list26.sort()
print(list26)

#   浅拷贝
list27 = [1,2,3,4,5]
list28 = list27
list28[1] = 200
print(list28)
print(list27)
print(id(list28),   id(list27))
#   深拷贝 内存的拷贝
list29 = [1,2,3,4,5]
list30 = list29.copy()
list30[1] = 100
print(list29)
print(list30)
print(id(list29),id(list30))

#   将元祖转换成列表
list31 = list((1,2,3,4))
print(list31)

#找出第二大的值
listNum = []
num = 0
while num < 10:
    val = int(input())
    listNum.append(val)
    num += 1
print(listNum)
listNum.sort()  #按照升序排序
count = listNum.count(listNum[len(listNum) -1])
c = 0
while c < count:
    listNum.pop()
    c += 1
print(listNum[len(listNum) -1])

#找出第二大的值
listNum = []
num = 0
while num < 10:
    val = int(input())
    listNum.append(val)
    num += 1

if listNum[0] >= listNum[1]:
    max = listNum[0]
    sec = listNum[1]
else:
    max = listNum[1]
    sec = listNum[0]

index = 2
while index < len(listNum):
    if listNum[index] >= sec:
        sec = listNum[index]
    if listNum[index] >= max:
        sec = max
        max = listNum[index]
    index += 1
print(sec)

元组

tuple
本质：是一种有序集合
特点：
1、与列表非常相似
2、一旦初始化就不能修改
3、使用小括号

#创建tuple
#格式：元组名 = (元组元素1, 元组元素2, ……, 元组元素n)

#创建空的元组
tuple1 = ()
print(tuple1)

#创建带有元素的元组
#元组中的元素的类型可以不同
tuple2 = (1,2,3,"good",True)
print(tuple2)

#定义只有一个元素的元组
tuple3 = (1,)
print(tuple3)
print(type(tuple3))

#   元组元素的访问
#   格式：元组名[]
#   下标从0开始
tuple4 = (1,2,3,4,5)
print(tuple4[1])
print(tuple4[-1])   #   获取最后一个元素
print(tuple4[-2])

#   修改元组
tuple5 =(1,2,3,4,[5,6,7])
#tuple[0] = 100  #报错，元组不能变
tuple5[-1][0] = 500
print(tuple5)

#   删除元组
tuple6 = (1,2,3)
del tuple6
#print(tuple6)

#   元组的操作
tuple7 = (1,2,3)
tuple8 = (4,5,6)
print(tuple7 + tuple8)

#   元组重复
tuple10 = (1,2,3)
print(tuple10 * 3)

#   判断元素是否在元组中
tuple11 = (1,2,3)
print(4 in tuple11)

#   元组的截取
#   格式：元组名[开始下标:结束下标]
#   从开始下标开始截取，截取到结束下标之前
tuple12 = (1,2,3,4,5,6,7,8)
print(tuple12[3:7])
print(tuple12[3:])
print(tuple12[:7])

#   二维元组:元素为一维元组的元组
tuple13 = ((1,2,3),(4,5,6),(7,8,9))
print(tuple13[1][1])

元组的方法

#len()  返回元组中元素的个数
tuple14 = (1,2,3,4,5)
print(len(tuple14))

#max()  返回元组中的最大值
print(max((5,6,7,8,9)))
#min()  返回元组中的最小值
print(min(1,2,3,4,5))

#将列表转成元组
list1 = [1,2,3]
tuple15 = tuple(list1)
print(tuple15)

#元组的遍历
for i in (1,2,3,4,5):
    print(i)

字典

概述：
使用键-值（key-value）存储，具有极快的查找速度
key的特性:
1、字典中的key必须唯一
2、key必须是不可变的对象
3、字符串、整数等都是不可变的，可以作为key
4、list是可变的，不能作为key

思考：保存多位学生的姓名与成绩
[["tom",60],["lilei",70]]

使用字典，学生姓名为key，学生成绩作为值
dict1 = {"tom":60, "lilei":70}

#元素的访问
#获取：字典名[key]
print(dict1["lilei"])
#print(dict1["li"]) #没有会报错
print(dict1.get("lilei"))
ret = dict1.get("li")
if ret == None:
    print("没有")
else:
    print("有")

#添加
dict1["hanmeimei"] = 99
#因为一个key对应一个value，所以，多次对一个key的value赋值，其实就是修改值
dict1["lilei"] = 80
print(dict1)

#删除
dict1.pop("tom")
print(dict1)

#遍历
for key in dict1:
    print(key,dict1[key])

for value in dict1.values():
    print(value)

for k,v in dict1.items():
    print(k,v)

for k,v in enumerate(dict1):
    print(k,v)

#和list比较
#1、查找和插入的速度极快不会随着key-vaule的增加而变慢
#2、需要占用大量的内存，内存浪费多

#list
#1、查找和插入的速度会随着数据量的增多而减慢
#1、占用空间小，浪费内存少

#   输入一个单词，判断出现了多少次
w = input()
d = {} # word:次数
str = "lee is a good man! lee is a nice man! lee is a greate man! lee is a hands man! lee is a good man! lee is a noble man!"

l = str.split(" ")
for v in l:
    c = d.get(v)
    if c == None:
        d[v] = 1
    else:
        d[v] += 1
print(d[w])

'''
1、以空格切割字符串
2、循环处理列表中的每个元素
3、以元素当做key去一个字典中提取数据
4、如果没有提取到，就以该元素作为key，1作为value存进字典
5、如果提取到，将对应的key的value修改，值加1
6、根据输入的字符串当做key再去字典取值
'''