张导博客：[https://www.cnblogs.com/Neeo/articles/11204572.html]

1.安装python和pycharm

image

1.1 安装PyCharm

image

image

image

注册码:http://idea.lanyus.com/

添加hosts解析
C:\Windows\System32\drivers\etc

image

image

image

image

image

1.2 安装python

image

1.3 添加环境变量

image

C:\Program Files\Python37
C:\Program Files\Python37\Scripts

image

image

image

cmd查看版本

image

第一句python

image

2. python起源

官方文档:https://docs.python.org/zh-cn/3/tutorial/index.html

image

1. pip 错误记录

相关链接:https://blog.csdn.net/cashcat2004/article/details/50664744

ERROR: Could not install packages due to an EnvironmentError: [WinError 5] 拒绝访问。: 'c:\\program files\\python37\\lib\\site-packages\\pip-10.0.1.dist-info\\entry_points.txt'
Consider using the `--user` option or check the permissions.

image

image

python -m pip uninstall pip #卸载原有的pip

下载get-pip.py文件，并将此文件保存在Python的安装目录下

网址：https://pypi.org/project/pip/

image

# 再次安装get-pip.py
python C:\Program Files\Python37\get-pip.py

博客资料链接:
https://www.cnblogs.com/Neeo/articles/10522363.html

image

2. python的基础数值类型

https://www.cnblogs.com/Neeo/articles/10562348.html

整型：int

整型数就是不包括小数部分的数值，分为整数、0和负数

浮点型：float

float类型的数值与数学中的写法基本一致，但允许小数点后面没有任何数字（小数部分为0）,在Python 3.x中，运算符/用于浮点数时，是保留小数部分的，而Python 2.x版本解释器则返回int类型

布尔类型：bool

判断两个数是否相等时,可以判断命题真假的语句,将真假两个值组成了一个类型，即布尔类型，真假值也称为布尔值，以真假为值的表达式称为布尔表达式

- bool
- python中,元素自带布尔值
有三个(类)元素布尔值为假,其余为真
  - 0
  - 空,包括:
    - 空的字符串 ''
    - 空的列表 []
    - 空的字典 {}
    - 空的元组 ()
- None

3. 变量

我们通过一个名字，指向一个人，或者指向一个具体的事物。这在Python中是同样适用。Python中，这个名字称为变量，而指向的对象为一串字符串，一个具体的数值等等。变量也是可变状态的、对内存地址一种抽象。

变量赋值

变量赋值是指将一个数字或者字符串等具体的数值数据赋值给一个变量，在后面的编程中我们可以通过这个变量来指向所要引用的数据对象

>>> v = 100
>>> v
100
>>> v+20
120
>>>

3.1 变量标准数据类型

在内存中存储的数据可以有多种类型。

例如，一个人的年龄可以用数字来存储，他的名字可以用字符来存储。

Python 定义了一些标准类型，用于存储各种类型的数据。

Python有五个标准的数据类型：

• Numbers（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Dictionary（字典）

3.2 变量的规则

• 第一个字符必须是字母（大写或小写）或者一个下划线（_）
• 变量的其他部分可以是字母（大写或小写）、下划线（_）、数字（0-9）组成
• 变量是对大小写敏感的。如，oldboy和oldBoy不是一个变量
• 变量命名时注意避开关键字和内置的函数名，以免发生冲突
• 变量的第一个字符不能是数字
• 命名要见名知意
• 推荐写法：下划线(user_name) 驼峰体(userName)

#比较规范
name = "oldboy"
age = 18

而不是这种：

mingzi = "oldboy"
nianling = 18
a = "male"
b = "不详"

我们还应该避免：

• 单字符名称
• 包/模块名中的连接符避免用中横线-
• 避免双下划线开头并结尾的名称，因为这是Python保留的，比如__init__

3.3 内存管理

垃圾回收机制

image

int整形

image

float整形
计算小数

image

计算加减乘除

image

3.5 输入输出

input：接收的输入都转为字符串形式

print()：可以接收多个参数

end='\n'

sep=' '

file=文件句柄

4. 运算符

知识链接:
https://www.cnblogs.com/Neeo/articles/10522370.html

表达式：由操作数和操作符组成的表达式

4.1 算数运算符

image

>>> 1 + 1       # 运算符 +  
2  
>>> 1 - 1       # 运算符 -  
0  
>>> 1 * 1       # 运算符 *  
1  
>>> 1 / 1       # 运算符 /  
1.0  
>>> 4 // 3      # 取整除 //  
1  
>>> 10 % 3      # 取模 %  
1  
>>> 2 ** 2      # 幂 **  
4  

4.2 比较运算符

image

>>> 2 == 2      # 比较运算符 ==  
True  
>>> 2 != 2      # 比较运算符 !=  
False  
>>> 2 > 2       # 比较运算符 >  
False  
>>> 2 < 2       # 比较运算符 <  
False  
>>> 2 >= 2      # 比较运算符 >=  
True  
>>> 2 <= 2      # 比较运算符 <=  
True  

4.3 赋值运算符

image

>>> a = 5  
>>> b = 3  
>>> c = a + b   # 赋值运算符 =  
>>> c  
8  
>>> b += a      # 赋值运算符 +=  
>>> b  
8  
>>> b -= a      # 赋值运算符 -=  
>>> b  
3  
>>> b *= a      # 赋值运算符 *=  
>>> b  
15  
>>> b /= a      # 赋值运算符 /=  
>>> b  
3.0  
>>> b %= a      # 赋值运算符 %=  
>>> b  
3.0  
>>> b **= a     # 赋值运算符 **=  
>>> b  
243.0  
>>> b //= a     # 赋值运算符 //=  
>>> b  
48.0  

4.4 逻辑运算符

image

>>> 2 < 3 and 3 == 3    # 逻辑运算符 and  
True  
>>> 2 < 3 or 3 != 3     # 逻辑运算符 or  
True  
>>> not 1 > 2           # 逻辑运算符 not  
True  

登录验证

image

4.5 成员运算符

image

image

4.6 身份运算符

image

>>> a = 'abcd'  
>>> b = a  
>>> c = a  
>>> b is a         # 身份运算符 is  
True  
>>> b is c  
True  
>>> c is not a     # 身份运算符 is not  
False 

image

4.7 位运算符(了解)

image

>>> a = 8  
>>> b = 5  
>>> a & b       # 按位与  
0  
>>> a ^ b       # 按位异或  
13  
>>> a | b       # 按位或  
13  
>>> a << b      # 左移  
256  
>>> a >> b      # 右移  
0  

4.8 运算符的优先级

image

image

5. 流程控制语句

知识链接：
https://www.cnblogs.com/Neeo/articles/10522374.html

image

5.1 条件语句

if 判断条件:  
    执行的代码块1  
else:  
    执行的代码块2  

Python条件语句是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块

s = input('输入一个成绩: ')
s_int = int(s)
s_int = int('s')    #错误的，如果输入单引号，变量值

#条件语句 if/elif/else

s = input('输入一个成绩: ')
s_int = int(s)

if 90 <= s_int <= 100:
    print('成绩优秀!')
elif 80 <= s_int < 90:
    print('成绩良好')
elif 60 <= s_int <80:
    print('成绩一般')
elif 0 <= s_int < 60:
    print('成绩不合格')
else:
    print('输入成绩错误')

image

if 嵌套

image

python中，元素自带布尔值

有三个元素布尔值为空

print(bool(0))  # 0
print(bool('')) 
#空字符串 ‘’
#空的列表 []
#空的字典 {}
#空的元组 ()
print(bool(None)) #空

5.2 while循环

https://www.runoob.com/python/python-loops.html

条件一：while循环成立的条件

条件二：

# while循环

a = 0
b = 0
while a < 100:
    a += 1
    b += a
print(b)

#第二种显示过程的方法

count = 0   #用于循环出0-100的值
sum = 0 #用于求和的变量
s = '0'
while count < 100:
    print(count, sum)
    count += 1
    sum += count
    s += '+' + str(count)
    print('%s = %s'% (s, sum))
 #   print(sum)

while True:
    input('你划呀')
    print('给你十位小姐姐')

5.3 for循环

# 序列类型
for loop in '12345':    
    print("The value is: %s" % loop)

%s 整型
%f 小数

image

while嵌套循环

count = 0
while count < 3:
    num = 0
    while num <= 3:
        print('*' * num)
        num += 1
    count += 1

#执行结果
*
**
***

*
**
***

*
**
***

6.1 break: 终止循环

break: 终止整个循环,后续循环不会执行，并且break后面的代码也不执行

count = 0
while count <= 10:
    print(count)
    if count == 6:
        break
        print(222222)
    count += 1
#执行结果
0
1
2
3
4
5
6

6.2 continue

continue 语句跳过本次循环，continue语句用在while和for循环中。

continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环，continue语句后面的代码也不会执行

https://www.runoob.com/python/python-continue-statement.html

# 打印1,2，3,4,5,6，7,8,9,10

count = 0
while count < 10:
    count += 1
    if count == 7:
        continue
        print(23333333)
    print(count)
#执行结果
1
2
3
4
5
6
8
9
10

6.3 pass语句

pass 是空语句，是为了保持程序结构的完整性。

pass不做任何事情，一般用做占位语句

7.简述变量命名规范

1.不能以数字开头，第一个字符必须是字母或者下划线

2.变量由字母，下划线，数字组成

3.变量要注意大小写的区别，例如abc不等于ABC

4.变量名要避免与关键字和函数名发生冲突

5.变量第一个字母不能是数字

8.name = input(“>>>”) name变量是什么数据类型？

字符串类型 （String）

9.if条件语句的基本结构？

if 判断条件:
   执行语句...
else:
   执行语句...

10.用print打印出下面内容：only one print

用一个print

⽂能提笔安天下, 
武能上马定乾坤。
⼼存谋略何⼈胜, 
古今英雄唯是君。

no_1 = '⽂能提笔安天下,'
no_2 = '武能上马定乾坤。'
no_3 = '⼼存谋略何⼈胜,'
no_4 = '古今英雄唯是君。'
print('\r', no_1, '\n', no_2, '\n',no_3, '\n',no_4)

image

11.利用if语句写出猜大小的游戏：

设定一个理想数字比如：66，让用户输入数字，如果比66大，则显示猜测的结果大了；如果比66小，则显示猜测的结果小了;只有等于66，显示猜测结果正确。

# 定义一个变量并输出
num = 66
speck = int(input('请输入您要猜的数字(须是整数): '))
# 条件语句 if/elif/else
if speck > num:
  print('您猜大了哦!再猜一次')
elif speck < num:
  print('您猜小了哦!再猜一次')
elif speck == num:
  print('恭喜您猜对了！奖励老婆一车!')

注意，为什么input函数要放在int函数内，还记得之前讲input的时候，说过input函数返回的是str类型么？因此，这里要转换为int类型，不然无法和int类型的成绩做判断。但这就限制了input的输入类型了，比如你输入你的名字就不行了，因为int函数无法转换。
if语句支持很多运算符来丰富条件语句，如比较运算符、成员运算符、逻辑运算符、算数运算符等。

12.提⽰⽤户输入他的年龄, 程序进⾏判断.

如果⼩于10, 提⽰⼩屁孩, 如果⼤于10, ⼩于 20, 提⽰青春期叛逆的⼩屁孩. 如果⼤于20, ⼩于30. 提⽰开始定性, 开始混社会的⼩ 屁孩⼉, 如果⼤于30, ⼩于40. 提⽰看老⼤不⼩了, 赶紧结婚⼩屁孩⼉. 如果⼤于40, ⼩ 于50. 提⽰家⾥有个不听话的⼩屁孩⼉. 如果⼤于50, ⼩于60. 提⽰⾃⼰⻢上变成不听 话的老屁孩⼉.如果⼤于60, ⼩于70. 提⽰活着还不错的老屁孩⼉. 如果⼤于70, ⼩于 90. 提⽰⼈⽣就快结束了的⼀个老屁孩⼉. 如果⼤于90以上. 提⽰. 再见了这个世界.

while True:
  age = int(input('请输入您的年龄:'))
  if 0 <= age < 10:
      print('⼩屁孩!')
  elif 10 <= age < 20:
      print('青春期叛逆的⼩屁孩')
  elif 20 <= age <30:
      print('开始定性, 开始混社会的⼩ 屁孩⼉')
  elif 30 <= age < 40:
      print('看老⼤不⼩了, 赶紧结婚⼩屁孩⼉')
  elif 40 <= age < 50:
      print('家⾥有个不听话的⼩屁孩⼉')
  elif 50 <= age < 60:
      print('⾃⼰⻢上变成不听 话的老屁孩⼉')
  elif 60 <= age < 70:
      print('活着还不错的老屁孩⼉')
  elif 70 <= age < 90:
      print('⼈⽣就快结束了的⼀个老屁孩⼉')
  elif 90 < age:
      print('再见了这个世界')
  else:
      print('年龄输入有误!')
      exit()

13.单行注释以及多行注释？

#单行注释
井号'#'单行注释

#三引号包含内容进行注释
''' 
内容
'''

ctrl+?  选择多行注释
ctrl+a ctrl+?   选择全文注释

14.提⽰⽤户输入⿇花藤. 判断⽤户输入的对不对. 如果对, 提⽰真聪明, 如果不对, 提⽰输入有误

name = input('你知道王者农药的爸爸是谁吗?请告诉我: ')
a = '麻花藤'
if name == a:
  print('真棒！儿子')
else:
  print('猜错了哦！太low了')

#娱乐版

# 定义选项，B为正确
A = 'A.我不爱钱的杰克马'
B = 'B.你充钱了吗麻花藤'
C = 'C.爱妻如命的刘强东'
D = 'D.百度卖药的李彦宏'
# 显示问题与选择
print('你知道王者农药的爸爸是谁吗?''\n', A, '\n', B, '\n', C, '\n',D)
while True:
    name = input('\t\t\t\t''请告诉我答案: ')
    # if/elif/else判断
    if name == 'A':
        print('真棒！猜错了龟孙儿')
    elif name == 'B':
        print('恭喜你!麻花藤为你冲了10个Q币\n并赠送老婆一车!')
        exit()
    elif name == 'C':
        print('真棒！你猜错了龟孙儿')
    elif name  == 'D':
        print('真棒！你猜错了龟孙儿')
    else:
        print('蠢吗猪！给你选项都不填！')

image

15.⽤户输⼊⼀个分数. 根据分数来判断⽤户考试成绩的档次

>=90        A     
>=80        B  
>=70        C  
>=60        D           
< 60        不及格 

# ⽤户输⼊⼀个分数. 根据分数来判断⽤户考试成绩的档次
while True:
   print('=====考试成绩查询====\n[666]exit')
   num = int(input('请输入您要查询的成绩[1-100]: '))
   if num == 100:
       print('该生成绩[A+] 满分\n送老婆一车!')
   elif 90 <= num < 100:
       print('该生成绩[A] 优秀')
   elif 80 <= num < 90:
       print('该生成绩[B] 良好')
   elif 70 <= num < 80:
       print('该生成绩[C] 一般')
   elif 60 <= num < 70:
       print('该生成绩[D] 及格')
   elif 0 <= num < 60:
       print('该生成绩不及格! 待补考')
   elif num == 666:
       print('欢迎使用...')
       exit()
   else:
       print('输入成绩有误!请重新输入')

image

16. 字符串基本操作

image

# 按索引取值

s = 'abcdef'
print(s[0])
print(s[-2])
print(s[0:2])   # 取范围
print(s[0:6])
print(s[0:6:1])
print(s[0:6:2])   # 取a c e
print(s[0:3:1])
#输出结果
a
e
ab
abcdef
abcdef
ace # 取a c e
abc

image.png

str1 = 'http://www.xxxxxx.com/'
print(str1[-3])        # 取倒数第三个
print(str1[0:6])       # 取前六个字符
print(str1[5:-1])      # 从第六个字符开始取到末尾
print(str1[3:7])       # 从3到8个字符之前取值
print(str1[0:-1:2])    # 两者之间 每2个字符取一个
print(str1[0:-1:4])    # 所有字符中每4个取一个
print(str1[::-1])      # 反转字符串 通过负数的步进 实现反转

注意：

字符串反转 print(s[::-1])

17. 字符串的拼接

字符串的拼接（合并） +
字符串的合并操作，也叫字符串的拼接，此操作应用十分广泛

>>> '100' + '-' + '1800' + '-' + '18000'  
'100-1800-18000' 

**字符串的复制 **

>>> name = 'oldboy'  
>>> name * 5  
'oldboyoldboyoldboyoldboyoldboy' 

相当于将元字符复制5份，组成新的字符串。

字符串成员测试：in，not in

>>> 'o' in 'oldboy'  
True  
>>> 'ol' in 'oldboy'  
True  
>>> 'od' in 'oldboy'  
False  
>>> 'od' not in 'oldboy'  
True  

字符串格式化运算符： %系列

字符串的格式化输出。格式化输出就是按照某种固定的格式进行字符串输出，这个字符串称为模板字符串，我们在模板里用格式定义符%占住一个空位，然后我们把运算得出的数据再放到这个空位里，字符串格式化运算符%的基本用法如下：

<模板字符串> % (<数据1>， …，数据n>)  

%s这个字符串格式化运算符就是说我要往字符串中放入的数据是字符串类型的值，这也是最常用的用法，但仅凭%s不足以包打天下，所以，这一节我们在学习几个其他常用的与%搭配的其他的字符，以实现不同的功能，比如商店消费的小票上，或者银行等涉及到金钱的输出都有固定格式，比如我们怎么用格式化输出￥1.50呢？你可能会说，简单，这样干：

>>> "金额：￥%s 元" % 1.50  
'金额：￥1.5 元'  

最后一位没显示出来，很明显，%s在这种情况下并不好使，所以我们面对类似的情况就要用别的格式化运算符了——浮点型%f。

>>> "金额：￥%.2f 元" % 1.50  
'金额：￥1.50 元'  

<模板字符> %[flags][width].[precision]<模板字符> % (数据1, … 数据n)

上例各参数说明如下：

• 模板字符就是普通的字符串。
• flags可以是+、-或0，+表示右对齐（默认右对齐，加号不写，写上会显示出来），-表示左对齐。
• width表示显示宽度。
• precision表示小数的位数。

print("金额：￥%+9.2f 元" % 1.50000) 
print("金额：￥%-9.2f 元" % 1.50000)  
print("金额：￥%09.2f 元" % 1.50000) 

#输出结果
金额：￥    +1.50 元
金额：￥1.50      元
金额：￥000001.50 元

上例中：

• %+9.2f表示格式化字符右对齐（一般加号可以省略不写，写上的话，会当成格式化字符填充进去）、宽度是9，小数位保留2位，需要填充的是浮点型的数据。
• %-9.2f表示格式化字符左对齐，宽度是9，小数位保留2位，需要填充的是浮点型的数据。
• %09.2f表示格式化字符填充0，宽度是9，需要填充的是浮点型的数据。

要注意的是，如果使用的是浮点型的格式定义符，那么数据也必须是浮点型数据或int类型。

>>> "金额：￥%f 元" % 4  
'金额：￥4.000000 元'  
>>> "金额：￥%.2f 元" % 4  
'金额：￥4.00 元'  
>>> "金额：￥%.2f 元" % 'str'  
Traceback (most recent call last):  
  File "<stdin>", line 1, in <module>  
TypeError: a float is required   

这同样适用于其他的格式定义符，比如说如果是你用int类型的格式定义符“%d”,而你的数据是str类型，那就会报错。

>>> "金额：￥%d 元" % '1'  
Traceback (most recent call last):  
  File "<stdin>", line 1, in <module>  
TypeError: %d format: a number is required, not str  
>>> "金额：￥%d 元" % 1  
'金额：￥1 元'  

18. 字符串的常用方法

Python为字符串提供了很多方法，也有很多的内置函数和声明可以应用于字符串，比如说使用len(str)方法获取字符串的长度。这里我们仅介绍最常用的字符串方法。

18.1 str.strip('obj')

去除字符串两边的指定字符，默认去除字符串两边的空格或者换行符，没有指定字符则略过。返回去除指定字符后的新字符串。

s2 = '****oldb***oy*******'
print(s2.strip())  # ****oldb***oy*******
print(s2.strip('*'))  # oldb***oy

s = '*a*b  *'
print(s.strip('*'))
print(s.replace('*', ''))
print(s.replace('*', '', 2))

#执行结果
a*b  
ab  
ab  *

如上例所示，strip方法只能去除字符串两边的指定字符，那想把中间的星号去掉怎么办？

s2 = '****oldb***oy*******'
print(s2.replace('*', ''))  # oldboy

问题解决，但是replace是什么？

18.2 str.replace

str.replace(old, new, [max])

将字符串中指定字符替换成新的字符，替换次数最多不超过max次。返回替换后的新的字符串。

s1 = "'python是最美的语言', python said"
new_str = s1.replace('p', 'P')
print(new_str)  # 'Python是最美的语言', Python said
print(s1.replace('p', 'P', 1))  # 'Python是最美的语言', python said

18.3 str.split & str.rsplit

str.split(obj='', num) & str.rsplit(obj='', num)

以指定的字符分割字符串，可以指定分割次数，默认是全部分割，并以列表的形式返回。

s3 = "hello python"
print(s3.split('o'))  # ['hell', ' pyth', 'n']
print(s3.split('o', 1))  # ['hell', ' python']

分割字符串也就是说遇到指定的分割字符就以指定字符把字符串分两半！通过返回结果可以看到，这种分割顺序是从左到右开始的。对应的，我们也可以从右到左分割，我们可以用str.rsplit(obj='', num)完成：

s4 = "hello python"
print(s4.rsplit('o'))  # ['hell', ' pyth', 'n']
print(s4.rsplit('o', 1))  # ['hello pyth', 'n']

一般的，除了分割，包括替换在内的顺序都是从左到右地顺序，这是默认的。

18.4 str.join(sequence)

返回以指定字符将sequence连接后的新字符串。

s = 'abc' # a_b_c
print('_'.join(s))

#执行结果
a_b_c

需要注意的是，sequence中的元素必须是字符串类型，否则报错。

s6 = ['1', '2', '3']
s7 = [1, 2, 3]
print('-'.join(s6))  # 1-2-3
print('-'.join(s7))  # TypeError: sequence item 0: expected str instance, int found

上例中，s6和s7同为列表，但其内的元素类型不同，可以看到，如果其中的对象是int类型，就会报错。

18.5 str.upper() & str.lower()

返回字符串中英文字母大写形式的新字符串，非英文字母、本身就是大写形式的英文字母略过。

s8 = '张开说Python就像1+1等于2那么简单'
print(s8.upper())  # 张开说PYTHON就像1+1等于2那么简单

与之对应的是就是返回字符串中英文字母小写形式的新字符串，非英文字母、本身就是小写形式的英文字母略过。

s9 = '张开说Python就像1+1等于2那么简单'
print(s9.lower())  # 张开说python就像1+1等于2那么简单

这两个方法用处很多，比如我们在登录验证码的判断这里就可以用到，因为验证码是随机的，并且含有大小写和特殊字符的一串字符串，那么怎么判断呢，其中就可以通过upper()和lower()这两个方法来判断。

verification_code = '12n%C'
result = input('输入验证码: ')
if verification_code.upper() == result.upper():  # 也可以将验证码都以小写形式来判断
    print('验证码正确')
else:
    print('验证码输入错误')

18.6 str.index & str.find

str.index(obj) & str.find(obj)

返回字符串中指定字符的索引位置，顺序是从左到右的顺序，找到就返回。

s1 = 'abcd'
print(s1.find('a'))  # 0
print(s1.find('w'))  # -1

s2 = 'abcd'
print(s2.index('a'))  # 0
print(s2.index('w'))  # ValueError: substring not found

找到就返回这没错，但需要我们注意的是，如果字符串中不存在指定的字符，两个方法的返回结果也是不一样的，如果字符串没有指定字符，str.find返回-1，而str.index则报错。

18.7 str.startswith & str.endswith

str.startswith(obj) & str.endswith(obj)

判断字符串是否已指定字符开头或者结尾，并以布尔值的形式返回。

s = 'abcd'
print(s.startswith('a'))  # True
print(s.startswith('ab'))  # True
print(s.startswith('acb'))  # False

print(s.endswith('d'))  # True
print(s.endswith('cd'))  # True
print(s.endswith('cbd'))  # False

通过结果可以看到，指定字符如果是多个，必须是连续的。

18.8 str.count

str.count(obj, start=0, end=len(str))

返回字符串中，指定索引范围内的指定元素出现的次数，如果指定字符不在字符串中，则返回0。开始位置默认为0，结束位置为字符串结束的位置。

s = 'https://www.cnblogs.com/Neeo/'
print(s.count('w'))  # 3
print(s.count('w', 1, 10))  # 2
print(s.count('1'))  # 0

18.9 str.center

str.center( width， filler)

返回一个指定宽度的字符串，如果width的宽度小于字符串本身的宽度，就直接返回该字符串，否则字符串两边填充filler字符，filler默认是空格，且filler必须是单个字符，否则报错。

print('welcome to Linux111'.center(30, '☆'))

#执行结果
☆☆☆☆☆☆welcome to Linux111☆☆☆☆☆☆

18.10 str.format()

自Python 2.6版本开始，就增加了format函数，它增强了字符串格式化的功能，基本语法是通过“{}”和“:”来代替“%”。format函数可以接受不限个数的参数，位置也可不按顺序。下面通过示例来学习 一下format函数的用法：

• 按照默认顺序传参：

print('{} {}'.format('hello', 'Anthony'))  # hello Anthony

默认的，format将“hello”填充到第一个花括号内，将“oldboy”填充到第二个花括号内。相当于平行赋值。

• 按照指定位置传递参数：

print('{0} {1}'.format('hello', 'Anthony'))  # hello Anthony
print('{0} {0}'.format('hello', 'Anthony'))  # hello hello
print('{1} {0}'.format('hello', 'Anthony'))  # Anthony hello
print('{1} {1}'.format('hello', 'Anthony'))  # Anthony Anthony

上例中，我们可以这样理解，format内两个参数都有自己的位置序号。然后根据序号填充字符串。

• 设置参数：

s = 'name: {name} | url:{url}'
print(s.format(name='Anthony', url='https://www.cnblogs.com/Neeo/'))  # name: Anthony | url:https://www.cnblogs.com/Neeo/

上例中，我们为format中的参数起个别名，然后字符串根据别名填充对应的内容。

求字符串的长度

s = 'abcdefg'
print(len(s))

7

for i in s:
    print(i, s.index(i))

# 执行结果
a 0
b 1
c 2
d 3
e 4
f 5
g 6    

s = 'abcd'
print(max(s))  # d
print(min(s))  # a
print(len(s))  # 4

19. 字符集和编码详解

相关知识：https://blog.csdn.net/qq_42068856/article/details/83792174
https://www.cnblogs.com/Neeo/articles/11215938.html

20. 作业

1.有变量name = "aleX leNb" 完成如下操作：

# 1.有变量name = " aleX leNb " 完成如下操作：
name = "aleX leNb"

# 移除 name 变量对应的值两边的空格,并输出处理结果
print(name.strip()) # aleX leNb

# 移除name变量左边的"al"并输出处理结果
print(name[2:-1])   # eX leN

# 移除name变量右面的"Nb",并输出处理结果
print(name[0:-2])   # aleX le

# 移除name变量开头的a"与最后的"b",并输出处理结果
print(name[1:-1])   # leX leN

# 判断 name 变量是否以 "al" 开头,并输出结果
print(name.startswith('al'))    # True

# 判断name变量是否以"Nb"结尾,并输出结果
print(name.endswith('Nb'))  # True

# 将 name 变量对应的值中的 所有的"l" 替换为 "p",并输出结果
print(name.replace('l', 'p'))   # apeX peNb

# 将name变量对应的值中的第一个"l"替换成"p",并输出结果
print(name.replace('l', 'p', 1))    # apeX leNb

# 将 name 变量对应的值根据 所有的"l" 分割,并输出结果。
print(name.split('l'))  # ['a', 'eX ', 'eNb']

# 将name变量对应的值根据第一个"l"分割,并输出结果。
print(name.split('l', 1))   # ['a', 'eX leNb']

# 将 name 变量对应的值变大写,并输出结果
print(name.upper())  # ALEX LENB

# 将 name 变量对应的值变小写,并输出结果
print(name.lower())  # alex lenb

# 将name变量对应的值首字母"a"大写,并输出结果
print(name.title())  # Alex Lenb

# 判断name变量对应的值字母"l"出现几次，并输出结果
print(name.count('l'))  # 2

# 如果判断name变量对应的值前四位"l"出现几次,并输出结果
print(name.count('l', 0, 4))    # 1

# 从name变量对应的值中找到"N"对应的索引(如果找不到则报错)，并输出结果
print(name.index('N'))  # 7

# 从name变量对应的值中找到"N"对应的索引(如果找不到则返回-1)输出结果
print(name.find('N'))   # 7

# 从name变量对应的值中找到"X le"对应的索引,并输出结果
print(name.count('X le'))   # 1

# 请输出 name 变量对应的值的第 2 个字符?
print(name[1:2])    # l

# 请输出 name 变量对应的值的前 3 个字符?
print(name[:3])  # ale

# 请输出 name 变量对应的值的后 2 个字符?
print(name[-2:])    # Nb

# 请输出 name 变量对应的值中 "e" 所在索引位置（两个e都找）?
#此题解法：https://zhidao.baidu.com/question/425671789131374252.html
find = 'e'
print([i for i,v in enumerate(name) if v==find])    # [2, 6]

20.2 有字符串s = "123a4b5c"

通过对s切片形成新的字符串s1,s1 = "123"
s1 = s[:3]
print(s1)   # 123

通过对s切片形成新的字符串s2,s2 = "a4b"
s2 = s[3:6]
print(s2)   # a4b

通过对s切片形成新的字符串s3,s3 = "1345"
s3 = s[0:-1:2]
print(s3)   # 1345

通过对s切片形成字符串s4,s4 = "2ab"
s4 = s[1:-1:2]
print(s4)   # 2ab

通过对s切片形成字符串s5,s5 = "c"
s5 = s[-1]
print(s5)   # c

通过对s切片形成字符串s6,s6 = "ba2"
s6 = s[-3::-2]
print(s6)   # ba2

20.3 使用while和for循环分别打印字符串s="asdfer"中每个元素

# while循环
s = "asdfer"
num = 0
while True:
    print(s[num])
    num += 1
    if num == len(s):
        break

# for循环
s = "asdfer"
for i in s:
    print(i)

20.4 使用for循环对s="asdfer"进行循环，但是每次打印的内容都是"asdfer"。

s = "asdfer"
for i in s:
    print(s)

20.5 使用for循环对s="abcdefg"进行循环，每次打印的内容是每个字符加上sb，

例如：asb, bsb，csb,...gsb。

s = "asdfer"
for i in s:
    print(i + 'sb')

#执行结果
asb
ssb
dsb
fsb
esb
rsb

20.6 使用for循环对s="321"进行循环，打印的内容依次是："倒计时3秒"，"倒计时2秒"，"倒计时1秒"，"出发！"。

s = "321"
for i in s:
    # print('倒计时'+i+'秒')
    print('倒计时{}秒'.format(i))
print('出发!')

#执行结果
倒计时3秒
倒计时2秒
倒计时1秒
出发!

20.7 实现一个整数加法计算器(两个数相加)：

如：content = input("请输入内容:") 用户输入：5+9或5+ 9或5 + 9，然后进行分割再进行计算。

# 思路：将输入的空格可以替换为空，利用str.replace
# 分割'+'号
content = input("请输入相加的整数;格式[x+y]: ").replace(' ', '')
num = content.split('+')
print(int(num[0] + num[1]))

20.8 升级题：实现一个整数加法计算器（多个数相加）：

如：content = input("请输入内容:") 用户输入：5+9+6 +12+ 13，然后进行分割再进行计算。

# 使用for循环，先将'+'号分割定义变量，然后再利用int整型计算相加

content = input("请输入相加的整数;格式[x+y]: ").replace('', '')
num = content.split('+')
s = 0
for i in num:
    s += int(i.strip())
print(s)

# 使用for循环，直接分割后利用int整型计算相加

content = input("请输入相加的整数;格式[x+y]: ").replace('', '')
s = 0
for i in content.split('+'):
    s += int(i.strip())
print(s)

image

20.9 计算用户输入的内容中有几个整数（以个位数为单位）。

如：content = input("请输入内容：") # 如fhdal234slfh98769fjdla

str.isdigit()方法：https://www.runoob.com/python/att-string-isdigit.html

content = input("请输入内容: ").replace('', '')
s = 0
# 利用str.isdigit 如果字符串只包含数字则返回True的方法来统计输了多少个数字
for i in content.strip('+'):
    if i.isdigit():
        s += 1
print('您一共输入了[', s, ']个整数')

image

# 对照第八题的思路
# 使用for循环，直接分割后利用int整型计算相加计算整数的和
# 使用了俩个for循环，第一个实现和的计算，第二个实现输入整数的统计

content = input("请输入相加的整数;格式[x+y]: ").replace('', '')
# 定义两个变量
n = 0
s = 0
for j in content.split('+'):
    n += int(j.strip())
print('和为:', n)

# 利用str.isdigit 如果字符串只包含数字则返回True的方法来统计输了多少个数字
for i in content.strip('+'):
    if i.isdigit():
        s += 1
print('您一共输入了[', s, ']个整数')

image

20.10 写代码，完成下列需求：(升级题)

用户可持续输入（用while循环），用户使用的情况：
输入A，则显示走大路回家，然后在让用户进一步选择：
是选择公交车，还是步行？
选择公交车，显示10分钟到家，并退出整个程序。
选择步行，显示20分钟到家，并退出整个程序。
输入B，则显示走小路回家，并退出整个程序。
输入C，则显示绕道回家，然后在让用户进一步选择：
是选择游戏厅玩会，还是网吧？
选择游戏厅，则显示 ‘一个半小时到家，爸爸在家，拿棍等你。’并让其重新输入A，B, C选项。
选择网吧，则显示‘两个小时到家，妈妈已做好了战斗准备。’并让其重新输入A，B, C选项。

while True:
    print('☆耶 下课了！你打算去做什么呢？''\n\t', 'A.走大路回家☆', '\n\t', 'B.走小路回家☆', '\n\t', 'C.绕远道回家☆')
    xz = input('请告诉你的选择[A|B|C]: ')
    # xz = input('>>>:').strip()
    if xz.upper() == 'A':
        print('你选择了走大路回家')
        xz = input('☆是选择\n\tA.公交车\n\tB.还是步行？')
        if xz.upper() == 'A':
            print('10分钟后到家...')
            break
        elif xz.upper() == 'B':
            print('20分钟后到家...')
            break
    elif xz.upper() == 'B':
        print('你选择了走小路回家\n路上要小心色狼')
        break
    elif xz.upper() == 'C':
        print('你选择了绕远道回家')
        xz = input('☆是选择\n\tA.游戏厅玩会\n\tB.还是网吧？')
        if xz.upper() == 'A':
            print('一个半小时到家，爸爸在家，拿棍等你。')
        elif xz.upper() == 'B':
            print('两个小时到家，妈妈已做好了战斗准备。')
        else:
            print('输入错误')
    else:
        print('输入错误')

#选择A 执行过程
☆耶 下课了！你打算去做什么呢？
     A.走大路回家☆ 
     B.走小路回家☆ 
     C.绕远道回家☆
请告诉你的选择[A|B|C]: a
你选择了走大路回家
☆是选择
    A.公交车
    B.还是步行？a
10分钟后到家...
Process finished with exit code 0

#选择B 执行过程
☆耶 下课了！你打算去做什么呢？
     A.走大路回家☆ 
     B.走小路回家☆ 
     C.绕远道回家☆
请告诉你的选择[A|B|C]: b
你选择了走小路回家
路上要小心色狼

Process finished with exit code 0

#选择C 执行过程
☆耶 下课了！你打算去做什么呢？
     A.走大路回家☆ 
     B.走小路回家☆ 
     C.绕远道回家☆
请告诉你的选择[A|B|C]: C
你选择了绕远道回家
☆是选择
    A.游戏厅玩会
    B.还是网吧？A
一个半小时到家，爸爸在家，拿棍等你。
☆耶 下课了！你打算去做什么呢？    # 返回，重新输入
     A.走大路回家☆ 
     B.走小路回家☆ 
     C.绕远道回家☆
请告诉你的选择[A|B|C]: C
你选择了绕远道回家
☆是选择
    A.游戏厅玩会
    B.还是网吧？B
两个小时到家，妈妈已做好了战斗准备。  
☆耶 下课了！你打算去做什么呢？    # 返回，重新输入
     A.走大路回家☆ 
     B.走小路回家☆ 
     C.绕远道回家☆
请告诉你的选择[A|B|C]: 

20.11 写代码，有如下列表，按照要求实现每一个功能

li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
计算列表的长度并输出
列表中追加元素"seven",并输出添加后的列表
请在列表的第1个位置插入元素"Tony",并输出添加后的列表
请修改列表第2个位置的元素为"Kelly",并输出修改后的列表
请将列表l2=[1,"a",3,4,"heart"]的每一个元素添加到列表li中，一行代码实现，不允许循环添加。
请将字符串s = "qwert"的每一个元素添加到列表li中，一行代码实现，不允许循环添加。
请删除列表中的元素"ritian",并输出添加后的列表
请删除列表中的第2个元素，并输出删除的元素和删除元素后的列表
请删除列表中的第2至4个元素，并输出删除元素后的列表
请将列表所有得元素反转，并输出反转后的列表
请计算出"alex"元素在列表li中出现的次数，并输出该次数。

20.12 写代码，有如下列表，利用切片实现每一个功能

li = [1, 3, 2, "a", 4, "b", 5,"c"]
通过对li列表的切片形成新的列表l1,l1 = [1,3,2]
通过对li列表的切片形成新的列表l2,l2 = ["a",4,"b"]
通过对li列表的切片形成新的列表l3,l3 = ["1,2,4,5]
通过对li列表的切片形成新的列表l4,l4 = [3,"a","b"]
通过对li列表的切片形成新的列表l5,l5 = ["c"]
通过对li列表的切片形成新的列表l6,l6 = ["b","a",3]

20.13 写代码，有如下列表，按照要求实现每一个功能。

lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
将列表lis中的"tt"变成大写。
将列表中的数字3变成字符串"100"。
将列表中的字符串"1"变成数字101。

20.14 请用代码实现：

li = ["alex", "wusir", "taibai"]
利用下划线将列表的每一个元素拼接成字符串"alex_wusir_taibai"

21.列表

资料连接：https://www.cnblogs.com/Neeo/articles/11212368.html

列表是Python中最常用的数据类型之一，也是最灵活的数据类型之一，其可以包含任何种类的对象：数字、字符串、元组、字典，也可以嵌套的包含列表。当然与字符串不同的是，列表是可变的，可变指的是我们在原处修改其中的内容，如删除或增加一个元素，则列表中的其他元素自动缩短或者增长，也正是如此，在列表元素个数过多时，如果你删除靠前的（如第一个）元素，其他的元素都要向前移动，会导致性能有所下降，这是在开发中需要注意的。

21.1 创建列表

在Python中，用一对中括号[]来表示列表（list），用,分割列表内的每个元素。

l = []
print(l)  # []
print(type(l))  # <class 'list'>
print(list('abcdefg'))  # ['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(list(range(-1, 4)))  # [-1, 0, 1, 2, 3]
print(list(range(1, 11)))   # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(list(range(1, 11, 3))) # [1, 4, 7, 10]

21.2 列表合并（拼接）： +

l1 = [1, 2, 3]
l2 = ['a', 'b', 'c']
l3 = l1 + l2
print(l3)  # [1, 2, 3, 'a', 'b', 'c']

合并（拼接）就是将两个列表合为一个新列表，原有列表不变。

21.3 列表的重复：*

l1 = [1, 2, 3]
l2 = l1 * 3
print(l2)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

重复可以理解为将原列表复制指定次数，然后相加得到一个新的列表。

21.4 列表成员资格判断：in，not in

l = ['a', 'b', 'we']
print('a' in l)  # True
print('w' not in l)  # True
print('we' in l)  # True

成员资格测试就是判断指定元素是否存在于列表中，存在则返回True，不存在则返回False。

21.5 通过索引取值

l = ['a', 'b', 1, 2]
print(l[0])  # a
print(l[6])  # IndexError: list index out of range

列表中每一个元素都有自己的索引（从0开始）位置，这也是为什么说列表是有序的原因。我们可以通过索引取对应的值。
注意，当通过索引取值时，索引范围超过列表索引长度时，会报错，因为没有这个索引位置。

21.6 切片

l = ['a', 'b', 'c', 'd', 'e', 'f', 'g']

# 从指定索引位置开始取值
print(l[3:])  # ['d', 'e', 'f', 'g']
# 取列表内的一段元素
print(l[3:6])  # ['d', 'e', 'f']
# 每隔两个取一个
print(l[1:6:2])  # ['b', 'd', 'f']
# 取索引为-2的元素
print(l[-2])  # f
# 从左向右取，从0开始，取到倒数第二个之前的
print(l[:-2])  # ['a', 'b', 'c', 'd', 'e']
# 反转列表
print(l[::-1])  # ['g', 'f', 'e', 'd', 'c', 'b', 'a']

切片是根据列表的索引来取值（取范围内的值），需要说明的是，只要是序列类型（字符串，列表，元组），其内的元素都有自己的索引位置，我们可以根据索引位置取值，切片。

21.7 for循环取值

l = ['a', 'b', 'c', 'd']
for i in l:
    print(i)
'''
a
b
c
d
'''

for循环取值时，每次循环取出一个元素，然后将这个元素赋值给i，我们就可以通过操作i来操作取出的元素。

21.8 列表元素更新

l = ['a', 'b', 'c', 'd']
print(l, id(l))  # ['a', 'b', 'c', 'd'] 128337600
l[1] = 'w'
print(l, id(l))  # ['a', 'w', 'c', 'd'] 128337600

通过指定的索引修改列表中对应的元素，并且通过打印结果发现，当列表内的元素被修改后，列表的内存地址不变。

21.9 删除列表（元素）

l = ['a', 'b', 'c', 'd']
del l[0]
print(l)  # ['b', 'c', 'd']
del l[0], l[1]
print(l)  # ['c']
del l
print(l)  # NameError: name 'l' is not defined

使用del关键字进行列表元素的删除，del支持删除多个元素。但要注意的是，删除多个元素的时候，需要牢记，要删除的第一个元素后面的元素此时还在索引范围内。
另外，当删除列表中的指定索引后，如果该索引后面还有元素，则后面所有的元素都会往前位移，或者称为补位。
当使用del删除整个列表后，这个列表就不存在了，也就是最后的报错。
还有一点需要注意：

l = ['a', 'b', 'c', 'd']
del l[1], l[2]
print(l, len(l))  # ['a', 'c'] 2
del l[3]  # IndexError: list assignment index out of range

原列表的最大索引为3，删除两个元素后，此时列表最大的索引为2，此时却要删除索引为3的元素，就抛出错误了。

21.10 总结，列表中的常用操作符：

列表中的常用方法：

同样的，还有其他置函数或者声明语句可以应用于列表：

需要注意的，max()和min()函数都需要列表内的元素类型保持一致，不然没法比较啊！
另外，cmp()函数在Python 3.x中不存在了，如果要使用类似功能，可以使用operator代替，它适合任何对象：

import operator
print(operator.eq([1, 2], [2, 1]))  # False

或者使用更简单的方式：

print([1, 2] > [2, 1])  # False
print([1, 2] == [2, 1])  # False
print([1, 2] != [2, 1])  # True

22. 列表的常用方法

22.1 list.append(obj)

将一个对象（元素）追加到列表的末尾。这只是一个追加操作，并且是原地操作列表，所以该方法没有返回值。

l = ['a', 'b', 'c', 'd']
l.append(1)
print(l)  # ['a', 'b', 'c', 'd', 1]
l.append('w')
print(l)  # ['a', 'b', 'c', 'd', 1, 'w']

由打印结果可以看到，两个元素都已追加的形式被存放在列表的尾部。

22.2 list.insert(index, obj)

将一个对象（元素）插入到列表的指定索引的前面。这只是一个插入操作，并且是原地操作列表，所以该方法没有返回值。

l = ['a', 'b', 'c', 'd']
l.insert(1, 1)
print(l)  # ['a', 1, 'b', 'c', 'd']

可以看到，我们通过insert操作在列表索引为1的元素前面插入一个新元素1。
需要注意的是，就如插队一样，前面插入一个人，后面的人都要往后移动一位，如果列表长度很长的话，会对性能有所影响。

In [2]: %timeit list(range(100000)).append('a')
3.25 ms ± 22.9 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

In [3]: %timeit list(range(100000)).insert(0, 'a')
3.36 ms ± 99.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

上例，我们通过ipython测试同样是十万个元素的列表，一个执行将元素追加到列表的尾部，一个执行将元素插入到列表的头部，可以看到，追加操作需要耗费3.25ms，而插入操作需要3.36ms。

22.3 list.pop([obj])

移除列表中的指定索引位置的元素，若不指定索引，默认移除列表尾部的元素，并且将列表返回（返不返回是我的事儿，接不接收是你的事儿）。

l = ['a', 'b', 'c', 'd']
print(l.pop(1))  # b
print(l.pop())  # d
print(l.pop(9))  # IndexError: pop index out of range
print(l.pop('d'))  # TypeError: 'str' object cannot be interpreted as an integer

前三个打印好解释，最后一个打告诉我们字符串无法解释为整型，也就是说，list.pop(obj)移除操作要么是指定元素下标，要么什么都不指定，按照人家默认的来，而不能指定删除某个元素。

22.4 list.remove(obj)

删除列表中的指定元素，不指定或指定元素不存在报错，而且仅是删除操作，没有返回值。

image

l = ['a', 'b', 'c', 'd']

l.remove('a')
l.remove('c')
print(l)  # ['b', 'd']
l.remove(1)  # ValueError: list.remove(x): x not in list

最后报错说删除的指定元素不存在。

22.5 list.reverse()

反转列表，并没有参数和返回值，只是在原地对列表中的元素进行反转。

l = ['a', 'b', 'c', 'd']
l.reverse()
print(l)  # ['d', 'c', 'b', 'a']

22.6 list.sort(key=None, reverse=False)

原地对列表进行排序，key是自定义的排序算法，此函数在每次元素比较时被调用，reverse表示排序方式，默认的false是按照升序进行排序的，当reverse=True时，排序结果为降序。

image

l = ['a', 'c', 'b', 'd']
l.sort()
print(l)  # ['a', 'b', 'c', 'd']
l.sort(reverse=True)
print(l)  # ['d', 'c', 'b', 'a']

我们来看看key参数怎么使用：

l = ['abc', 'cae', 'edg', 'ffh']
l.sort(key=lambda x: x[1])
print(l)  # ['cae', 'abc', 'edg', 'ffh']

通过key指定以每个元素中的索引为1的元素排序。
需要补充的是sorted(key=None, reverse=False)函数，它是Python内置的对于所有序列类型进行排序的函数，而不像sort()方法是列表独有的排序方法。
二者区别是：

• sort方法仅能对列表进行原地排序，没有返回值。
• sorted函数对所有序列类型进行排序，并且并不是原地排序，它会返回排序结果，也就是说我们可以通过一个变量接收排序结果。

需要注意的是，无论使用哪种排序方式，排序对象必须是同类型的，也就是说，如果排序对象是列表，那么列表内的元素都为同一类型，因为不同类型无法比较。

转换为字符串

image

image

image

23. 列表的嵌套

image

如果嵌套层数过多，可以使用递归的方法，扩展项

前文介绍列表时说的元素类型丰富，就是说列表不仅能存储数字、字符串，还能存储列表。

>>> l = [1, 2, [3, 4]]    
>>> for i in l:    
...     print(i)    
...    
1    
2    
[3, 4]    
>>> l[2]    
[3, 4]    
>>> l[2].pop()    
4    
>>> l    
[1, 2, [3]]    
>>> l[2].insert(0,'a')    
>>> l    
[1, 2, ['a', 3]]    

可以看到，列表对嵌套部分处理也同样的简单，可以使用我们学过的方法， 不仅如此，列表还可以存储别的数据结构，如字典、元组、集合。

>>> l = [1,(2, 3), [4,[5, 6]], {'a':'b'}, {7, 8}]    
>>> for i in l:    
...     print(i)    
...    
1    
(2, 3)    
[4, [5, 6]]    
{'a': 'b'}    
{8, 7}    
>>> l[1][1]    
3    
>>> l[2][1][1] = 'c'    
>>> l[3]['a']    
'b'    
>>> l[-1]    
{8, 7}    
>>> l    
[1, (2, 3), [4, [5, 'c']], {'a': 'b'}, {8, 7}]    

先不管元组、字典、集合的是什么。但并不推荐这么用，因为这样操作起来太不方便，只是演示列表可以各种嵌套，一般使用中，更多的是嵌套一种数据类型，如列表嵌套元组，列表嵌套字典，但很少有同时嵌套元组和字典的。
那么，我们如何展示列表中的所有元素呢？这里我们可以使用嵌套循环完成。

>>> for i in [1, [2, 3], 4]:  
...     if isinstance(i, list):  
...         for j in i:  
...             print(j)  
...     else:  
...         print(i)  
...  
1  
2  
3  
4  

上例中，第1行for循环列表，第2行判断每次循环中的元素是否为列表，如果是列表，那么就再用for循环循环打印其内的列表中的元素。否则执行第5行的else语句直接打印列表内的元素。

需要强调的是，Python中并没有二维数组的概念，但是列表嵌套列表同样能够达到相同的目的

24.元组tuple

资料链接：https://www.cnblogs.com/Neeo/articles/11212374.html

Python的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

创建空元组

tup1 = ()

元组中只包含一个元素时，需要在元素后面添加逗号

tup1 = (50,)

元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

24.1 元组的基本操作

创建元组

Python中，元组（tuple）用一对小括号()表示，元组内的各元素以逗号分隔。

t = ()
print(type(t))  # <type 'tuple'>
t1 = ('name', )
print(t1)  # ('name',)
print(type(t1))  # <type 'tuple'>

元组中特别注意逗号的使用，一不小心创建的元组就会成为字符串。

t = ('name')
print(t, type(t))  # ('name', <type 'str'>)
t1 = ('name', )
print(t1, type(t1))  # (('name',), <type 'tuple'>)

索引和切片

元组中索引和切片的用法跟列表和字符串类似，或者取范围内的值，或者可以指定在一段范围内，每几个取一个：

t = ('a', 'b', 'c', 'd', 'e')
# 按照索引取值
print(t[1])  # b
print(t[-1]) # e

# 取两者之间（范围）的值
print(t[0:4])  # ('a', 'b', 'c', 'd')
print(t[0:5:2])  # ('a', 'c', 'e')

# 反转元组，返回反转后的新的元组，原本的元组不变
print(t[::-1])  # ('e', 'd', 'c', 'b', 'a')

# for循环取值
for i in t:
    print(i)
'''
a
b
c
d
e
'''

但与列表不同的是，元组身为不可变类型，无法原地修改其中的值。

t = ('a', 'b', 'c', 'd', 'e')
t[2] = 'w'

'''
TypeError: 'tuple' object does not support item assignment
'''

拼接： +

虽然元组无法原地修改其中的元素，但是，通过+号可以把两个元组合并为一个新的元组。

t1 = ('a', 'b')
t2 = ('c', 'd', 'e')
t3 = t1 + t2
print(t3)  # ('a', 'b', 'c', 'd', 'e')

元组的重复：*

简单来说，正如字符串的重复一样，当对元组使用*时，复制指定次数后合并为一个新的元组。

t1 = ('a', 'b')
t2 = t1 * 2
print(t2)  # ('a', 'b', 'a', 'b')

成员资格测试： in，not in
与字符串、列表的成员资格测试在元组中同样适用：

t1 = ('a', 'b', 'abc')
print('a' in t1)  # True
print('b' not in t1)  # False

需要注意的是，成员资格判断，只是会判断某个元素是否存是元组的一级元素，比如上例中的a是元组的一级元素。而c不是元组的一级元素。在元组中，c是元组一级元素字符串abc的子串。所以判断结果为False。

序列（元组）类型的打包与解包

t = 1, 2, 3
x, y, z = t
print(x, y, z)  # 1 2 3

上例第1行，将1、2、3打包赋值给变量t，相当于将3个苹果打包到一个盒子内。第2行，从盒子t中将3个苹果取出来，分别交给x、y、z，我们称为解包。解包这里需要注意的是，盒子里有几个苹果，必须有几个对应的变量接收。多了不行，少了也不行。

平行赋值

>>> x, y = 1, 2  
>>> x,y  
(1, 2)  
>>> x  
1  
>>> type(x)  
<class 'int'>  
>>> a = x,y  
>>> a  
(1, 2)  
>>> type(a)  
<class 'tuple'>  

如上例第1行所示，平行赋值就是等号右边的1，2分别赋值给等号左边的x，y。第2行就是打包了（只是打包，并没有赋值给某个变量），并且打包后的结果是元组类型。而在第8行将x，y打包并赋值给变量a。此时a就是打包后的元组了。

通过打印斐波那契序列来练习平行赋值：

x, y = 0, 1
while x < 8:
    x, y = y, x + y
    print(x)
'''
1
1
2
3
5
8
'''

首先定义x，y两个变量并赋值。在每次循环中，x和y值都会重新赋值。

删除元组

注意，这里说的删除仅是删除整个元组，而不是删除元组中某个元素。

>>> t = (1, 2, 3)  
>>> del t[1]  
Traceback (most recent call last):  
  File "<stdin>", line 1, in <module>  
TypeError: 'tuple' object doesn't support item deletion  
>>> del t  
>>> t  
Traceback (most recent call last):  
  File "<stdin>", line 1, in <module>  
NameError: name 't' is not defined  

上例第2行，通过删除元组内的元素导致报错，又一次的证明元组为不可变类型。但我们可以删除整个元组(第6行)。

24.1.1 总结，元组中常用的操作符：

另外，还有几个内置的函数可以应用于元组：

24.2 元组的嵌套

与列表一样，元组也能嵌套存储数据：

t = (1, (2, 3), [4, [5, 'c']], {'a': 'b'}, {8, 7})
for item in t:
    print(item)
'''
1
(2, 3)
[4, [5, 'c']]
{'a': 'b'}
{8, 7}
'''

元组内可以存储的数据类型相当丰富，也可以发现，嵌套元素也会当成一个整体称为元组的子元素。但是我们说元组是不可更改的，但我们发现其中是由列表的，这是怎么回事？

t = (1, (2, 3), [4, [5, 'c']], {'a': 'b'}, {8, 7})
t[0] = 'x'  # TypeError: 'tuple' object does not support item assignment

通过上例，可以发现，元组内的普通元素不允许修改，但是列表是可变，我们能否把列表替换为别的元素呢？

t = (1, (2, 3), [4, [5, 'c']], {'a': 'b'}, {8, 7})
print(t[2])  # [4, [5, 'c']]
t[2] = 'w'  # TypeError: 'tuple' object does not support item assignment

通过上例也可以发现，如果列表被当成了元组的普通元素，那么它也是不可以修改的，遵循元组不可变特性。但是我们如果试图修改列表中的子元素呢？

t = (1, (2, 3), [4, [5, 'c']], {'a': 'b'}, {8, 7})
t[2][0] = 'w'
print(t)  # (1, (2, 3), ['w', [5, 'c']], {'a': 'b'}, {8, 7})

上例，可以发现，t[2][0]指的是列表中的第一个元素，我们在第2行修改它，然后发现是可以修改成功的。这是为什么呢？元组内的普通元素不允许修改，嵌套的子元素是否能够修改取决于这个子元素本身属于什么数据类型，如这个子元素是列表，那就可以修改，如果是元组，就可不以修改。

那么，了解完元组，你可能更有疑问了，除了不可变之外，元组跟列表没啥区别么？我们通过与列表的对比，来证明存在即是真理！

需要注意的是，元组并没有增、删功能。那么元组如此设计，以放弃增、删为代价换来了什么呢？

性能！是的，换来了性能！不信请看，以下演示代码由IPython（Python的另一个发行版本）完成。

24.3 list列表与元组tuple的对比

24.3.1 list VS tuple：创建（生成）速度

我们通过创建同样大小的list和tuple，来观察有什么变化：

In [1]: % timeit [1, 2, 3, 4, 5]
139 ns ± 2.34 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [2]: % timeit (1, 2, 3, 4, 5)
17.3 ns ± 0.161 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)

上例的意思是说我们创建一个长度为5的列表，大概执行了7次大循环，每次大循环中进行10000000次小循环。这个7次大循环，每次耗时（平均值）139 ns，每次（标准）偏差2.34 ns。而创建同样长度的元组，每次仅耗时17.3 ns，对比创建列表的耗时139 ns，可以看到创建元组的速度快很多。

24.3.2 list VS tuple：存储开销

再来看他们的存储开销：

from sys import getsizeof
l = [1, 2, 3, 4, 5]
t = (1, 2, 3, 4, 5)
print(getsizeof(l))  # 56
print(getsizeof(t))  # 48

可以看到，元组在存储空间上面也占优势。

24.3.3 list VS tuple：遍历速度

元组的遍历性能相比列表也是快很多了

image

24.3.4 list VS tuple：哈希比较

l = [1, 2, 3, 4, 5]
t = (1, 2, 3, 4, 5)
print(hash(t))  # -1883319094
print(hash(l))  # TypeError: unhashable type: 'list'

简单来说，Hash，一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来确定唯一的输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。

Python中可哈希（hashable）类型：字符串、元组、对象。可哈希类型就是我们常说的不可变类型，优点是性能经过优化，多线程安全，不需要锁，不担心被恶意篡改或者不小心修改了。

不可哈希类型：字典、列表、集合。相对于可哈希类型，使用起来相对灵活。

image

24.4 为数组添加元组

image

25. 字典dict

资料链接：https://www.cnblogs.com/Neeo/articles/11212385.html

我们知道，无论字符串、列表、元组都是将数据组织到一个有序的结构中，然后通过下标索引处理数据，这几种数据结构虽然已经满足大多数场景了，但是依然不够丰满，现在了解一种通过名字（key）来处理数据的数据类型，这种名字对应数值的关系我们称之为映射关系，而这种数据类型就是前文或多或少的了解过的——字典（dict）。字典是目前为止，Python唯一的内建的映射类型的数据类型。需要说明的是，从Python 3.6开始，字典元素的存储顺序由各键值对根据存储时的顺序而定（但依然不支持索引取值），并优化了空间上的开销，更节省内存占用。

通过存储同样的数据，利用列表和字典的不同之处来学习字典。比如存储商品的名称和编号，可以用列表来存。

有三个商品，对应三个价钱，那想要知道banana的价钱怎么办？

goods = ['apple', 'orange', 'banana']
price = ['20', '24', '32']
banana = price[goods.index('banana')]
print(banana)  # 32

如上例这样取值很麻烦，而且，你可能要问为什么价钱要存成字符串类型？

goods = ['apple', 'orange', 'banana']
price = [20, 24, 32]
banana = price[goods.index('banana')]
print(banana)  # 32

上例虽然可以存储为int类型。但要是存个电话号码呢？比如存010998998这样的数字怎么存？

number = [010, 998, 998]  # SyntaxError: invalid token

这个问题告诉我们，碰到类似的数据，或者是0开头的数据，尽量存储为字符串类型，而不是整型。另外，虽然列表能存储多种数据类型，但是通过上面的商品和价钱的例子，在用列表的时候，应该尽量存储数据为单一的类型。
好，言归正传，再来看看更好的选择。

goods = {'apple': '20', 'orange': '24', 'banana': '32'}
print(goods['banana'])  # 20

上例采用了字典来存储数据，接下来就学习一下字典的用法。

25.1 字典基本操作

字典详细讲解：https://www.cnblogs.com/Neeo/articles/11212385.html

字典是无序（Python 3.6版本之前）的可变类型数据类型。我们通过一对{}来创建字典（dict），字典内的值是通过:来存储的，也就是key:value的格式。

d1 = {}
d2 = dict()
print(d1, d2)  # {} {}
d3 = {'apple': 20}
print(d3)  # {'apple': 20}
print(d3['apple'])  # 20

25.1.1 使用内建函数dict()来创建字典

d = dict(apple='20', orange='24')
print(d)  # {'apple': '20', 'orange': '24'}

25.1.2 字典的增删改查

d = dict(apple=20, orange=24)
print(d['apple'])  # 字典取值
d['apple'] = 40  # 为字典的apple键重新赋值
print(d)
d['banana'] = 32  # 为字典新添加一对键值对
print(d)
del d['apple']
del d['orange'], d['banana']
del d

我们可以通过字典加中括号的形式，来对字典进行增删改查的操作。但需要注意的是，通过中括号取值的时候和del声明删除字典的key时，该key必须存在，否则报错（KeyError）。

列表的成员资格测试是不稳定的，而字典稳定。这是因为列表的成员资格判断取决于判断元素处于列表的什么位置，如果是列表的靠前位置，速度肯定快，如果是末尾，就要从头到尾挨着判断，速度就慢下来了。
而字典的存储结构是由key、哈希表、value三部分组成的，字典在创建一个键值对的时候，首先将key通过哈希得到结果，结果的位置上就是value，然后这个对应关系被保存在哈希表上。查询的时候，无论该key在何方，只要哈希后根据结果去哈希表上就能找到对应的value。所以查询速度快而且稳定，但由于要维护哈希表，在存储和修改时可能会相对麻烦些。

image

不是什么元组都能成为字典的key
需要注意的是，如果字典的key是元组，那么这个元组就不能是普通的元组了。我们知道元组是可哈希的数据类型，这种说法是基于元组内的元素都是不可变类型才成立的。

print(hash((1, 'a', 2.3, (4, 5))))  # -1680772126
t1 = (1, 'a', 2.3, (4, 5), [6, 7])
print(t1)  # (1, 'a', 2.3, (4, 5), [6, 7])
print(hash(t1))  # TypeError: unhashable type: 'list'

image

25.2 字典的常用操作

遍历字典

d = {'a': 1, 'b': 2, 'c': 3}
for k in d:
    print(k)
'''
a
b
c
'''

由上例可以看到，遍历的时候，字典默认返回key，那么怎么分别取key和value呢？

d = {'a': 1, 'b': 2, 'c': 3}
print(d.keys())  # dict_keys(['a', 'b', 'c'])
for k in d.keys():
    print(k)
'''
a
b
c
'''
print(d.values())  # dict_values([1, 2, 3])
for k in d.values():
    print(k)
'''
1
2
3
'''

上例中，d.keys()取出来的是字典所有的key，而d.values()取出的是所有的value。
那怎么同时取key和value呢：

d = {'a': 1, 'b': 2, 'c': 3}
for k in d.items():
    print(k)
'''
('a', 1)
('b', 2)
('c', 3)
'''

for k, v in d.items():
    print(k, v)
'''
a 1
b 2
c 3
'''

第一个for循环，我们通过d.items()以元组的形式拿到key和value。第二个循环，相当于平行赋值，每次从d.items()中取出一个元组，然后平行赋值给k v两个变量。

dict.get(key, None)

之前说，我们通过字典加中括号取值的时候，当key不存在的时候，会报错：

d = {'a': 1, 'b': 2, 'c': 3}
print(d['a'])  # 1
print(d['w'])  # KeyError: 'w'

报错~嗯2333333，很明显是不行滴，怎么办呢，我们可以通过dict.get()方法来避免这个问题：

d = {'a': 1, 'b': 2, 'c': 3}
print(d['a'])  # 1
print(d.get('a'))  # 1
print(d.get('w'))  # None
print(d.get('w', 'hi man， 你想要的键不存在呀'))  # hi man， 你想要的键不存在呀

dict.get()可以获取指定的key，当key不存在的时候，默认会返回一个None，意思是没取到key，而且我们可以修改这个返回值，更加灵活。

dict.setdefault(key, None)

d = {'a': 1, 'b': 2, 'c': 3}
print(d.setdefault('a'))  # 1
print(d.setdefault('x', 'y'))  # y
print(d)  # {'a': 1, 'b': 2, 'c': 3, 'x': 'y'}

dict.setdefault()方法跟dict.get()方法类似，获取字典指定的key，存在则返回对应的value，如果key不存在的话，它会将我们指定的key添加到字典中，默认的value是None，该value也可以自己指定。

dict.update(obj)

字典可以拼接（+）吗？

d1 = {'a': 1, 'b': 2}
d2 = {'c': 3, 'd': 4}
d3 = d1 + d2  # TypeError: unsupported operand type(s) for +: 'dict' and 'dict'

显然是不行的！
但我们可以通过dict.upate()方法来完成类似的操作：

d1 = {'a': 1, 'b': 2}
d2 = {'c': 3, 'd': 4}
d2.update(d1)
print(d2)  # {'c': 3, 'd': 4, 'a': 1, 'b': 2}

此方法将一个字典（d1）的键值对一次性的更新到当前字典（d2），如果两个字典中存在同样的键，更新的时候，对应的值以另一个字典（d1）的值为准。
注意，字典的键是唯一的，但是值可以是相同的。

dict.pop() & dict.popitem()

我们在上面也了解过了del来删除字典以及删除字典的键，这里我们再介绍两个方法删除字典的键。

d = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
print(d.pop('a'), d)  # 1 {'b': 2, 'c': 3, 'd': 4}
# print(d.pop('w'))  # KeyError: 'w'
print(d.popitem())  # ('d', 4)

d.pop()方法删除字典指定的key，返回对应的value，如果key不存在，则抛出KeyError错误。
而d.popitem()在Python2.7（Python 2.x的最后一个版本）和Python3.6（及以上版本）删除的是最后一个key。而其他版本（如Python2.4和Python3.5版本）则是随机删除一对键值对。另外，如果字典为空，上述两个方法都将抛出KeyError的错误。

dict.clear()

要清空一个字典，使用dict.clear()方法，这没啥好解释的：

d = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
d.clear()
print(d)  # {}

dict.fromkeys()

d = dict.fromkeys(['a', 'b'], None)
print(d)  # {'a': None, 'b': None}
d1 = dict.fromkeys(['a', 'b'], '自定义value')
print(d1)  # {'a': '自定义value', 'b': '自定义value'}

dict.fromkeys(seq, None)用来生成字典 ，第一个参数seq为序列类型（如上例中的字符串，列表）作为字典的key，第二个参数为每一个key对应的value，如若不设置则默认为None。

dict.contains(key)

dict.__contains__(key)用来判断某一个key是否在字典中。

d = dict.fromkeys(['a', 'b'], None)
print(d.__contains__('a'))  # True

需要注意的是，dict.__contains__(key)适用于Python2和3中，而Python2中，多了一个d.has_key(key)的方法，同样用来判断key是否在字典中。但这方法在Python3中取消了。

d = dict.fromkeys(['a', 'b'], None)
print(d.__contains__('a'))  # True
print(d.has_key('b'))  # True

小结 字典中的常用方法或函数或者声明语句：

26. 漫谈爬虫

小实例：爬取校花网

image.png

'''
pip install requests    
pip install BeautifulSoup4  # 下载BeautifulSoup4
'''
import requests
from  bs4 import BeautifulSoup
response = requests.get(url='http://www.xiaohuar.com/hua/')
soup_obj = BeautifulSoup(response.text, 'html.parser')
div_obj = soup_obj.find(name='div', attrs={'class': 'demo clearfix'})
img_list = div_obj.find_all(name='img')
for item in img_list:
    item_url = 'http://www.xiaohuar.com' + item.get('src')
    img_path = item.get('alt') + '.' + item_url.rsplit('.')[-1]

    img_response = requests.get(item_url)
    f = open('./校花网图片/{}'.format(img_path), 'wb')
    f.write(img_response.content)
    f.close()
    print('{} 下载完毕...'.format(img_path))

image.png

小坑：下载BeautifulSoup4不成功

image

image

27.练习

昨日练习最后的四道题

27.1 写代码，有如下列表，按照要求实现每一个功能

li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
计算列表的长度并输出
列表中追加元素"seven",并输出添加后的列表
请在列表的第1个位置插入元素"Tony",并输出添加后的列表
请修改列表第2个位置的元素为"Kelly",并输出修改后的列表
请将列表l2=[1,"a",3,4,"heart"]的每一个元素添加到列表li中，一行代码实现，不允许循环添加。
请将字符串s = "qwert"的每一个元素添加到列表li中，一行代码实现，不允许循环添加。
请删除列表中的元素"ritian",并输出添加后的列表
请删除列表中的第2个元素，并输出删除的元素和删除元素后的列表
请删除列表中的第2至4个元素，并输出删除元素后的列表
请将列表所有得元素反转，并输出反转后的列表
请计算出"alex"元素在列表li中出现的次数，并输出该次数。

27.2 写代码，有如下列表，利用切片实现每一个功能

li = [1, 3, 2, "a", 4, "b", 5,"c"]
通过对li列表的切片形成新的列表l1,l1 = [1,3,2]
通过对li列表的切片形成新的列表l2,l2 = ["a",4,"b"]
通过对li列表的切片形成新的列表l3,l3 = ["1,2,4,5]
通过对li列表的切片形成新的列表l4,l4 = [3,"a","b"]
通过对li列表的切片形成新的列表l5,l5 = ["c"]
通过对li列表的切片形成新的列表l6,l6 = ["b","a",3]

27.3 写代码，有如下列表，按照要求实现每一个功能。

lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
将列表lis中的"tt"变成大写。
将列表中的数字3变成字符串"100"。
将列表中的字符串"1"变成数字101。

27.4 请用代码实现：利用下划线将列表的每一个元素拼接成字符串

li = ["alex", "wusir", "taibai"]
利用下划线将列表的每一个元素拼接成字符串"alex_wusir_taibai"