Python学习日志 Day2

l. 列表推导式（按需求生成一个列表）

（1）生成指定范围的数值列表

​ lst = [Expression for var in range]

（2）根据列表生成指定需求的列表

​ lst = [Expression for var in list]

（3）从列表中选择符合条件的元素组成新的列表

​ lst = [Expression for var in list if conditon]

var：循环变量

lst：列表名称

Expression：表达式，用于计算新列表的元素

eg:

#I的平方存入列表
lst = [i **2 for i in range(1,101)]

计算平均分

score=[[80, 95,78, 92],[91,85, 78,66], [100, 72,70,55], [99,85,56,77], [90,80,68, 75]]
lst1 = [sum(i)/len(i) for i in score]

二维列表

创建列表

row=['A',……]
colum=[1,……]
#数字和字符串进行运算，需要把数字的数据类型修改为字符串
lst = [[i+str(j) for j in colum] for i in row]

（2）元组

不可变序列

a. 创建

​ 赋值运算符：=

​ tuple()函数：

tuple('python')
#输出结果('p','y','t','h','o','n')
tuple([1,2,3,4,5])
#(1,2,3,4,5)
tuple(range(1,5))
#(1,2,3,4)

b. 删除元组

del lstname

c. 访问元组元素

索引：

print(lstname[索引/索引范围])

d. 修改元组元素（重新赋值）

不能对单个元素进行修改

也可以用+对两个元组进行连接

案例

计算竞赛选手成绩

学校组织歌唱比赛，一共请了10位评委,评委们给某选手的打分分别为"95, 93, 89,99, 78,92,96,67,81,75"，要求去掉最高分和最低分，其他分数的平均作为该选手的得分，设计一个程序来实现。

score = (95,93,89,99,78,92,96,67,81,75)
#*score代表多个值,最大、最小值赋值给两端，其余的值赋值给*
minscore,*score,maxscore=soreted(score)
print(score)
print(sum(score)/len(score))

元组和列表的异同

异	列表属于可变序列，它的元素可以随时修改或者删除;元组属于不可变序列，其中的元素不可 以修改，除非整体替换。 列表可以使用append()、extend()、 insert()、 remove()和pop(等 方法实现添加和修改列表元素 而元组没有这几个方法，所以不能向元组中添加和修改元素。同样，元组也不能删除元素。 列表可以使用切片访问和修改列表中的元素。元组也支持切片，但是它只支持通过切片访问元 组中的元素，不支持修改。 元组比列表的访问和处理速度快，所以当只是需要对其中的元素进行访问，而不进行任何修改 时，建议使用元组。
同	列表不能作为字典的键，元组可以元组和列表都属于序列，而且它们又都可以按照特定顺序存放一组元素,类型又不受限制

（3）字典

无序序列：字典和集合

字典：保存的内容以“键值对”的形式储存，键是唯一的，值可以有多个。

​ 特征：

​ 通过键而不是通过索引来读取数据。它是通过键将一系列的值 联系起来的， 这样就可以通过键从字典中获取指定项，但不能 通过索引|来获取。
​ 字典是任意对象的无序集合，各项是从左到右随机排序的，即 保存在字典中的项没有特定的顺序。这样可以提高查找效率。
​ 字典是可变的，并且可以任意嵌套字典，可以在原处增长或者 缩短，支持任意深度的嵌套(即它的值可以是列表或者其他的字 典)。
​ 字典中的键必须唯一
​ 不允许同一个键出现两次。
​ 字典中的键必须不可变。可以使用数字、字符串或者元组，但 不能使用列表。

a. 字典的创建和删除

创建：

直接创建——“键"和”之间用 ：分隔，相邻两个元素之间用，分隔

dictionary = {'key1':'value1','key2':'value2',...,'keyn':'valuen'}

通过映射函数创建——

dictionary = dict(zip(list1,list2))

—dict()函数，创建字典

—zip()，将多个列表或者元组对应位置的元素进行组合，如果想获取数据，则可以将zip对象使用tuple()函数转换为元组，也可以使用list()函数转换为列表

—list1，指定要生成字典的键

—list2，指定要生成字典的值，若list1、2的长度不同，以短的为准

dictionary = dict(key1=value1,key2=value2,...,keyn=valuen)

删除:

del dictionary

b. 通过键值访问字典

利用get（）方法获取指定键的值

dictionary.get(key[,default])

default：为可选项，用于当指定的键不存在时，返回一个默认值。

c. 修改和添加字典元素

添加——

dictionary[key] = value

删除——

删全部元素：dictionary.clear()

删某个元素：del dictionary[key]

使用字典对象的pop()方法删除并返回指定”键"的元素,以及使用字典对象的 popitem()方法删除并返回字典中的一个元素(返回键值对)。

从电话簿中根据名字查询电话号码

已经将姓名和电话号码以字典的形式保存，需要编制一个查询程序，根据姓名，。查找对应的电话号码，如果无法找到，则输出"查询信息不存在!

phone_ dict={
' zweig':634309,'einstein':840491,'goethe':870541, 'judy':677969,'tracy':268565,'david':925669,'heine':868654,' beethovon':781842,'mozart':647520,'helen':366366}
while Ture:
    name = input('请输入姓名（退出请按Q）：')
    if name == 'Q':
        break
    phone = phone_dict.get(name,'查询信息不存在！')
    print(name+'的电话号码是：',phone)

（4）集合

形式上，所有元素放在{}中，相邻元素之间用’，‘。

内容上，集合中的每个元素都是唯一的，同时集合是无序的。

a. 创建集合

​ 用{ }直接创建

​ setname = {element 1,element 2,...,element n}

​ set()函数创建

​ setname = set(iteration)

​ —iteration：表示要转换为集合的可迭代对象，可以是列表、元组、range对象等。如果是字符串，返回的集合将是包含全部不重复字符的集合。

b. 添加和删除元素

​ 集合是可变序列，可进行添加删除

​ ——添加

​ setname.add(element)

​ ——删除

​ del命令删除整个集合

​ pop()/remove()删除一个元素：pop()不需要参数，随机删除一个元素，并可以返回一个值（a=setname.pop()),可用于抽奖

​ clear()清空集合

c. 集合的交集、并集和差集运算

交集：& ——共同部分

并集：| ——合并所有

差集：- ——减去共同部分

对称差：^ ——去掉交集

容器总结

数据结构	是否可变	是否重复	是否有序	定义符号
列表（list）	可变	可重复	有序	[ ]
元组（tuple）	不可变	可重复	有序	( )
字典（dictionary）	可变	可重复	无序	{key:value}
集合（set）	可变	不可重复	无序	{ }

6.字符串

​ 一系列字符组成的序列，创建可以用单引号（‘’）、双引号（" “）和三引号（”’ '"）

a. 拼接字符串

​ 运用“+”运算符

b.计算字符串的长度

len(string)

​ 在实际开发程序时，有时需要获取字符串实际所占的字节数,即如果采用UTF-8编码,则汉字占3个字节，当采用GBK或GB2312时，汉字占2个字节。这时，可以通过使用encode() 方法进行编码后再获取。

c. 截取字符串(切片方法)

string[start:end:step]

d. 分割字符串

​ 把字符串按照指定分隔符切分为字符串列表。

str.split(sep,maxsplit)

​ ——sep：用于指定分隔符，可包含多个字符，默认为None，即所有空字符（空格、换行"\n"、制表符"\t"）

​ ——maxsplit：用于指定分割次数

e. 将序列元素连接成字符串

​ join()方法用于将序列中的元素以指定的字符连接生成一个新的字符串。其语法如下:
str.join(sequence)

——str: 分隔符，可以为空字符串。
——sequence:要连接元素序列，如列表、字符串、元组、字典

eg: print('/'.join(namelist))

f. 检索字符串

（1）count()方法

==用于检索指定字符串在另一个字符串中出现的次数。==如果检索的字符
串不存在，则返回0，否则返回出现的次数。
str.count(sub[ start[, end]])
——str:表示原字符串。
——sub:表示要检索的子字符串。
——start:可选参数，表示检索范围的起始位置的索引
——end:可选参数，表示检索范围的结束位置的索引

（2）find()和index()

==find()方法和index() 方法用于检索是否包含指定的子字符串。==两者都返
回首次出现该子字符串时的索引，区别在于前者如果检索的字符串不存在，则返回-1，而后者则会抛出异常。
str.find(sub[ start[ end]])
str.index(sub[, start[, end])
——str:表示原字符串。
——sub:表示要检索的子字符串。
——start:可选参数，表示检索范围的起始位置的索引
——end:可选参数，表示检索范围的结束位置的索引

（3）startswith()和endswich()

==startswith()方法用于检索字符串是否以指定子字符串开头。==如果是则
返回True,否则返回False。
str.startswith(prefix[ start[ end]])
str:表示原字符串。
prefix:表示要检索的子字符串。
==endswith() 方法用于检索字符串是否以指定子字符串结尾。==如果是返
回True,否则返回False,其原理和startswith() 类似。

g. 字母大小写转换

lower()方法用于将字符串中的大写字母转换为小写字母。如果字符串
中没有需要被转换的字符，则将原字符串返回。
str.lower()
——str为要进行转换的字符串。
upper()方法用于将字符串的小写字母转换为大写字母。如果字符串中
没有需要被转换的字符，则将原字符串返回。

str.upper()

每一个单词首字母大写

str.tittle()

h. 去除空格和特殊字符

可以使用strip()方法去除字符串左右两边的空格和特殊字符，也可以使用Istrip()方法去除字符串左边的空格和特殊字符，使用rstrip(方法去除字符串中右边的空格和特殊字符。

strip(方法
str.strip([chars])
Istrip()方法
str.lstrip([chars])
rstrip(()方法
str.rstrip([chars])
——str：为要去除空格的字符串。
——chars：为可选参数，用于指定要去除的字符，可以指定多个，如果设置chars为"@.“，则去除包括”@“或”.”。如果不指定chars参数，默认将去除空格、制表符”\t"、 回车符"\r"、换行符"\n"等。

I. 格式化字符串

（1）——“%”

格式化字符串是指先制定一个模板， 在这个模板中预留几个空位，然后再根据需要填上相应的内容。这些空位需要通过指定的符号进行标记(也称为占位符) ,而这些符号并不会显示出来。


（2）——format()

str.format(args)

—str：指定字符串的显示样式

—args：指定要转换的项，若有多项，用逗号分隔


当某个参数需要被调用多次时，可以在前面的大括号中写入fomat函数的元素的索引，进行调用。

案例

1. 检测回文

如果一个字符串从左侧读和从右侧读，完全相同，那么就称为回文，例如"LOL",编写一个程序，从键盘输入一个字符串，判断是否为回文。

mystr = input('请输入一个字符串：')
#mystr[::-1]对字符串进行逆序操作
if mystr == mystr[::-1]:
    print('{}是回文！'.format(mystr))
else:
    print('{}不是回文！'.format(mystr))

2. 加密和解密

恺撒密码是一种最为古老的对称加密体制。在古罗马时，恺撒大帝曾用来对军事情报进行加密和解密。其基本思想是:通过把字母移动一定的位数来实现加密和解密,明文中的所有字母都在字母表上向后按照一个固定数目进行偏移后被替换成密文，而密文中所有字母都在字母表上向前按照一个固定数目进行偏移后被替换成明文。
例如，当步长为3时，A被替换成D，B被替换成E,以此类推，X被替换成A:

#加密
original = input('请输入内容：')
result = ''
#遍历原始字符串中的字符
#ord获取字符的ASCII码,若在A~Z之间，则在原基础上向后偏移3个
#判断是否是大写：if i.isupper():
#判断是否是小写：if i.islower():
for i in original :
    if ord(i)>=ord('A') and ord(i)<=ord('Z'):
        n=ord('A')+(ord(i)-ord('A')+3)%26
    elif ord(i)>=ord('a') and ord(i)<=ord('z'):
        n=ord('a')+(ord(i)-ord('a')+3)%26
    else:
        n=ord(i)
    result+=chr(n)
print(result)
            
#解密
plaintext=''
for i in result:
    if ord(i)>=ord('A') and ord(i)<=ord('Z'):
        n=ord('A')(ord(i)-ord('A')-3)%26
    elif ord(i)>=ord('a') and ord(i)<=ord('z'):
        n=ord('a')(ord(i)-ord('a')-3)%26
    else:
        n=ord(i)
    plaintext+=chr(n)
print(plaintext)