置顶 |

Python(胶水语言)入门

python基础1

先安利学习网站

C语言中文网

博客网

菜鸟教程

一.Python相关

1.Python前景

爬虫工程师

​ 爬数据分析

Web开发工程师

​ 网页设计（前端）
通过后台处理，返回给前端（后端）
小程序，网站，app等

2.编程语言

1.何为编程语言

编程就是编写程序，程序就是一系列指令，告诉计算机做什么。

编程语言就是我们能让计算机识别的语言。

2.编程语言发展史

  • 机器码: 0 1

    ​ 二进制 八进制 十进制 十六进制

  • 汇编语言

  • 高级语言

    ​ 用人类的方式来编写程序

    ​ 高级语言的老大哥C

      Java   go python. 都有c的影子

    3.Python特点

    ​ Python（胶水语言）简单灵活易上手。可配合其他语言使用。可用于游戏开发，系统管理，web应用，web安全，爬虫……

    4.Python官网:(卡)

    网站以及问题

    ​ [官网]https://www.python.org/downloads/

    ​ 验证是否安装成功: cmd里输入python出现版本则成功
    为什么要加入环境变量呢？为了让计算机知道Python的位置
    如何卸载干净？打开控制面板——_卸载程序_找到卸载程序——卸载

    二.输入 &输出

    ​ 所有符号英文状态。必须有双引号

    1.输入input（“系统提示内容”）

    ​ input (“系统提示的内容”)#input是提示用户输入什么的
    input ()#获取你键盘输入的数据
    input (“请输入电话号:”)#程序运行后会暂停等待你回车，继续执行

    2.输出print(“输出内容”)

    ​ 怎么输出引号？

    三.注释

    给程序做批注的，不会显示到程序中去

    不想打印时可用

    • 单行注释
    1
    2
    3
    4
    5
    # 2022年10月19号
    # 作者：bucacg
    # 注释的demo
    input("请输入你的名字：")
    print("注释")

    • 多行注释

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      """
      三对引号内多行注释的内容，都不会对程序造成影响，
      但必须英文状态下的三对符号
      """

      """
      2022年10月19号
      作者：bucacg
      注释的demo
      """

    四.开发模式

    1.命令行模式（交互模式）

    • win + r 输入cmd ，打开黑窗口 》》 输入 Python 》》 这就是命令行模式

    2.文本模式（脚本模式）idle可打开

    • new file 新建 open file来修改，
    • 鼠标右键新建文本txt— 编写Python代码–修改文件名的后缀 为 .py
    • 两者区别：
      • 命令行不能长期保存代码 ，不太好进行 修改， 好处就是方便我们测试一些模块的简单使用，以及快速打印变量的值
      • 文本的就能够长期保存我们的代码 下次修改 也是比较方便， 我们一般开发也是基于文本模式

    五.数据类型与变量

    何为变量

    输出变量不需要引号

    目的：计算两个数的和

    场景：我们去超市购物，用菜篮来装东西（肉，菜，调味品）购物结束，需要去结算金额

    1
    2
    3
    4
    5
    6
    # a 表示青菜 价格
    # b 表示肉 价格
    a = 12   # a 存放了  数据 12 
    b = 32
    result = a+b
    print("最后结果为", a+b)

    小结：

    • 变量就是一个容器可以是菜篮子,存储各种数据，也可以存储一个数据
    • 程序用来处理数据的，变量则是用来存储数据的

    数据类型

    1
    2
    3
    4
    5
    6
    7
    8
    - int    （整形）  123 10000 
    - float  （浮点数） 3.14 
    - bool 布尔类型     True 真   False 假
    - str（字符串）  "引号里的就是字符串"
    - tuple（元组）
    - dict（字典）
    - list（列表）
    - set（集合）

    怎样知道一个变量的类型呢

    type(变量名) 会返回变量的类型

    在Python中，只要我们自己定义好变量后，解释器就会自动识别他的一个类型 ，不需要我们自动说明

    type一次只能查看一个数据类型

    int整形

    人数，日期，牙齿的数量，

    声明方式

    1
    2
    3
    4
    变量名 = 整数值
    a = 12
    b = 32
    d,f，e = 23,22222223,5662

    float 浮点型

    金钱，身高，体重，圆周率

    声明方式

    1
    2
    3
    4
    5
    变量名 = 浮点数
    num1 =  3.14
    height = 1.78
    print(height)
    print(type(height))

    注意：

    浮点类型的计算是不精准的，两个浮点值运算，可能会丢失精度(带小数点的十进制数据,转为二进制数据的时候会丢失) 0.3 -0.2 不等于0.1

    bool 类型

    生活的 真 与 假 

    1
    2
    3
    4
    变量名 = 布尔值

    flag = True
    lose = False
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35

    注意：

    - 首字母必须要大写，
    - 布尔类型，也可以是数值， 并且运算，True = 1  False = 0

    ## 五.标识符与关键字

    ### 什么是标识符

    ![1655048857217](D:/02%E5%8F%98%E9%87%8F%E4%B8%8E%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B.assets/1655048857217.png)

    ### 标识符规则

    - 标识符由字母、下划线和数字组成，且数字不能开头 

    ```python
        fromNo12	 #True   
    	from#12      #False
    	my_Boolean   #True
    	my-Boolean   #False
    	Obj2         #True
    	2ndObj       #False
    	myInt        #True
    	test1        #True
    	Mike2jack    #True
    	My_tExt      #True
    	_test        #True
    	test!32      #True
    	haha(da)tt   #False
    	int   # int 类型标识符  不要与Python解释器的重复，会产生冲突    #False
    	jack_roseint  #True  
    	jack&rose     #False
    	GUI           #False
    	G.U.I         #False

    Python 标识符是区分大小写 

    1
    Andy != andy

    命名规则

    • 见面知意

      起一个有意义的名字，尽量做到看一眼就知道是什么意思(提高代码可 读性) 比如: 名字 就定义为 name , 定义学生 用 student

    1655049741609

    驼峰命名法

    小驼峰式命名法（lower camel case）： 第一个单词以小写字母开始；第二个单词的首字母大写，例如：myName、aDog
    大驼峰式命名法（upper camel case）： 每一个单字的首字母都采用大写字母，例如：FirstName、LastName

    ​

    下划线命名法

    还有一种命名法是用下划线“_”来连接所有的单词，比如send_buf 、 save_img，

    小结：

    • 推荐使用下划线的命名法来定义变量名
    • 不要与关键字重名

    关键字

    1
    2
    3
    4
    and     as      assert     break     class      continue    def     del
    elif    else    except     exec      finally    for         from    global
    if      in      import     is        lambda     not         or      pass
    print   raise   return     try       while      with        yield
    • 通过Python shell 来查看关键字
    1
    2
    >>> import keyword 
    >>> keyword.kwlist

    或者

    1
    >>> help('keywords')

    小结：

    • 关键字的学习以及使用，咱们会在后面的课程中依一一进行学习。
    • 关键字不需要同学们进行记忆，大家只要经常使用，就会记住了
    • 变量名也不要与关键字重名

    六.运算符

    提到运算符，我想大家首先想到的就是加、减、乘、除之类，但python可以进行的运算有很多种，可不只加减乘除这么简单 ，我们写代码时常见的运算符有以下几种

    1.算术运算符

    下面以a=10 ,b=20为例进行计算

运算符 描述 实例
+ 加 两个对象相加 a + b 输出结果 30
- 减 得到负数或是一个数减去另一个数 a - b 输出结果 -10
* 乘 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200
/ 除 b / a 输出结果 2
// 取整除 返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
% 取余 返回除法的余数 b % a 输出结果 0
** 指数 a**b 为10的20次方， 输出结果 100000000000000000000

注意：混合运算时，优先级顺序为： ** 高于 * / % // 高于 + - ，为了避免歧义，建议使用 () 来处理运算符优先级。
并且，不同类型的数字在进行混合运算时，整数将会转换成浮点数进行运算。

2.赋值运算符

运算符 描述 实例
= 赋值运算符 把 = 号右边的结果 赋给 左边的变量，如 num = 1 + 2 * 3，结果num的值为7 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 单个变量赋值
>>> num = 10
>>> num
10

# 多个变量赋值
>>> num1, num2, f1, str1 = 100, 200, 3.14, "hello"
>>> num1
100
>>> num2
200
>>> f1
3.14
>>> str1
"hello"

# 输出多个变量
print(num1, num2, f1, str1)


复合赋值运算符

运算符 描述 实例
+= 加法赋值运算符 c += a 等效于 c = c + a
-= 减法赋值运算符 c -= a 等效于 c = c - a
*= 乘法赋值运算符 c *= a 等效于 c = c * a
/= 除法赋值运算符 c /= a 等效于 c = c / a
%= 取模赋值运算符 c %= a 等效于 c = c % a
**= 幂赋值运算符 c **= a 等效于 c = c **a
//= 取整除赋值运算符 c //= a 等效于 c = c // a

作业

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 1.用变量存储我们生活中的数值信息,并输出  
   ``年龄
   ``身高
   ``生日
   ``日期
   ``时间
 ``tips: 年龄为int类型 身高为float类型 生日为int类型 日期为int类型 时间 int类型
 
 2.用什么函数可以知道变量的类型
 	tips：自己定义两个变量，用Python内置函数
 
3.判断以下变量是否正确, 并且用True（对） False（错）表示对错
	_=6			(T) #正确但不建议
	_8=12		(T)
	6age=12 	(F)
	true=23 	(T)#True才是关键字，这里原则上正确，但是不符合规范
	print=22	(F)

	
4.用编程计算 a = 10，b = 20 的 加，减，乘，除。 并且打印出结果


5.交换两个变量的值，a = 10 ,b =20   变成 a =20 ,b=10  （面试题）
	不能直接复值 a =20 b =10
	tips：利用Python特殊机制
		  算数运算符
		  第三个变量
		  a,b=b,a
		  
6.变量赋值：如何将100赋值给变量A，将100.0赋值给变量B；并分别判断A，B的变量类型	

7.如何将 Hello，world!赋值给变量C，并判断C的变量类型

8.如何实现将对象 1, 2, john 同时复制给变量a,b,c(一行代码)

9.请找出下面代码的错误
   break=1  #  break为关键字
   print(break)

​

巩固博客

七.序列类型

字符串

用来存储描述性质的数据，eg：姓名，地址。自我介绍等。字符串是一个有序的集合

1
2
a  = 10000  # 什么类型   int
print(type(a))

字符串类型

1
2
3
4
5
6
7
8
9
10
str01 = "hello world"    # str
str02 = '女士，先生们下午好！'  # str

# 字符串引号的嵌套报错 
print('bucacg")    # 不能单双混合

      
print('人生苦短，'我用Python") # 解决print("'人生苦短，'我用Python")


三引号的使用:可以用来注释，也可以用来包裹一些常用的字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 一般都用来包裹 长的字符串
a="""床前明月光，疑是地上霜。举头望明月，低头思故乡
床前明月光，疑是地上霜。举头望明月，低头思故乡
床前明月光，疑是地上霜。举头望明月，低头思故乡


床前明月光，疑是地上霜。举头望明月，低头思故乡

床前明月光，疑是地上霜。举头望明月，低头思故乡
床前明月光，疑是地上霜。举头望明月，低头思故乡
床前明月光，疑是地上霜。举头望明月，低头思故乡
床前明月光，疑是地上霜。举头望明月，低头思故乡
"""
      
print(a)

# 多行注释 
"""
同学们好，我是多行注释
"""

# 一定要记住他们的区别，多行注释是 三引号 独占一行

小结：

  • 双引号或者单引号中的数据，就是字符串
  • 不能单双混合
  • 不能出现多对引号 print(‘我说:’晚上好’’) # 里面两对引号都是单引号

下标和切片

“下标” 就是编号，就比如超市的存储柜的编号，通过编号就能找到相应的存储空间

生活中的“下标”

  • 超市的存储柜
  • 高铁座位

字符串，列表，元组都支持下标索引， 字符串 实际上就是字符的数据集合， 索引支持的下标索引

切片：就是取出一部分 ，切出一部分数据， 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
# 语法
变量[下标]
变量[起始:结束:步长]

# demo；
hel_str = "大家晚上好，今天星期六"
#          0 1 2 3 45 6 7 8 9 10
print(hel_str[3]) # 上
print(hel_str[0:2]) # 大家
print(hel_str[2::2])  # '晚好今星六 '
print(hel_str[::-1])  # '六期星天今，好上晚家大'
print(hel_str[1:10])   # 这里 取到 1到9 
print(hel_str[11])    # 下标越界
>>> hel_str[:3]     # '大家晚'
>>> hel_str[:3:-1]  #'六期星天今，好'
>>> hel_str[::-1]   #'六期星天今，好上晚家大'
>>> hel_str[::2]    #'大晚好今星六'
>>> hel_str[::-2]   #'六星今好晚大'
>>> hel_str[:3:-2]  #'六星今好'
>>> hel_str[:3:2]   #'大晚'
>>> hel_str[::-100]  #'六'
>>> hel_str[::-10]   #'六大'
>>> hel_str[::-11]   #'六'
>>> hel_str[::-12]   #'六'
>>> hel_str[::-9]    #'六家'
>>>hel_str[:len(hel_str)/2]
""" 
输出结果为;
Traceback (most recent call last):
  File "<pyshell#18>", line 1, in <module>
    hel_str[:len(hel_str)/2]
TypeError: slice indices must be integers or None or have an __index__ method
意思是不是整数，解决方法是整除//
"""
hel_str[:len(hel_str)//2]
#'大家晚上好'
>>> hel_str[11]
'''
Traceback (most recent call last):
  File "<pyshell#20>", line 1, in <module>
    hel_str[11]
IndexError: string index out of range
超出范围
'''

super_people = "超级赛亚人"
                0 1 2 3 4
print(super_people[0:2])# 超级
print(super_people[4:2】#无结果
print(super_people[4:2:-1])# 人亚
print(super_people[4])# 人

总结

  • 下标 是从0开始 且不能越界（报错）
  • 切片 只包含 起始位置，不包含 结束位置，（取头不取尾）
  • 切片 空着不写，默认是全部取出
  • 步长 常用于逆序输出 [::-1]

列表

在实际开发中，经常需要将多个数据存储起来，以便后边的代码使用。列表list，是一个有序且可变的容器，在里面可以存放多个不同类型的元素。

列表会将所有数据都放在一对中括号[ ]里面，相邻数据之间用逗号,分隔

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# 语法
列表名 = [数据1， 数据2]
demo1 = ["2022", "jk", 18, True, 99.1]

# 列表里面,还可以再放列表 
a = [12,13,33]
b = [a,4,5,6]      #[[12, 13, 33], 4, 5, 6]
# 我想输出b里面的12
print(b[0]) # 取出[12,13,33]
print(b[0][0]) # 取出12

# 列表里的值是可以修改的
demo1[0] = 9999   #[9999, "jk", 18, True, 99.1]
demo1[:3]=1314
Traceback (most recent call last):
"""
Traceback (most recent call last):
  File "<pyshell#44>", line 1, in <module>
    demo1[:3]=1314
TypeError: can only assign an iterable
  这里修改切片的内容必须有[]
"""
>>> demo1[:3]=1314
TypeError: can only assign an iterable
>>> demo1[0:3]=[1314]
>>> demo1   #[1314, True, 99.1]
>>> demo1[:3]="1314"
>>> demo1   #['1', '3', '1', '4', True, 99.1]

小结：

虽然可以将不同类型的数据放入到同一个列表中，但通常情况下不这么做，同一列表中只放入同一类型的数据，这样可以提高程序的可读性。

元组(tuple)

元组（tuple），是一个有序且不可变的容器，在里面可以存放多个不同类型的元素。

元组的表现形式为用()小括号包裹起来的数据,里面的数据用逗号，隔开

但是在（）里面仅仅只有一个数据时为int类型，，除非数字后面加个逗号就是元组。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# 语法
变量名 = (数据1，数据2)
tu = (1,2,"dfds", [12,23,21,3,23,1])
tu = (11,)   #元组类型
>>> tu[-1]=1314
"""
Traceback (most recent call last):
  File "<pyshell#58>", line 1, in <module>
    tu[-1]=1314
TypeError: 'tuple' object does not support item assignment
元组类型的值不支持修改，可以重新赋值 （同字符串）
"""
>>> tu=(123)
>>> tu     #123
>>> str1="lalalala"
>>> str1[1]=123
"""
结果为：
Traceback (most recent call last):
  File "<pyshell#69>", line 1, in <module>
    str1[1]=123
TypeError: 'str' object does not support item assignment
"""
>>> str[1]="123"
"""
Traceback (most recent call last):
  File "<pyshell#70>", line 1, in <module>
    str[1]="123"
TypeError: 'str' object does not support item assignment
"""
age = (18)  # int类型
age = (18,) # tuple类型 --> 就算元组里面只有一个数据,也要加个逗号.否则不会被认为是元组

小结：

元组的用法和列表基本类似,有两个不同之处:
1.元组用小括号,列表用中括号

2.元组里面的数据,是不可以改变的，如果修改就得重新赋值(字符串也是不可变类型)

  1. tuple类型 –> 就算元组里面只有一个数据,也要加个逗号.否则不会被认为是元组

如果你要保存的数据,可能会修改 –> 列表来保存
如果你要保存的数据,不会修改 –> 元组来保存

序列类型特点：

  • 能存储多个数据
  • 内部数据有序
  • 能通过下标获取
  • 通过切片切割
  • 字符串和元组不能修改，列表可以。

数据类型转换

为了满足我们需求 需要 把一些数据，转换为别的类型

1
2
3
4
5
6
7
8
9
10
11
# int(数据) --> 把数据转为整形
# float(数据) --> 把数据转为浮点型形
# bool(数据) --> 把数据转为布尔形
# str(数据) --> 把数据转为字符串
# list(数据) --> 把数据转为列表
# tuple(数据) --> 把数据转为元组
# input可以用来给变量赋值
# 万能方法 eval()  ---> 只对字符串有效  #一般不要使用
name = input('输入姓名')
age = input('输入年龄')  #age为str类型

注意：

  • input输入,得到的数据,默认是str类型.有些时候需要存储数字类型 则 int/float 进行类型转换，
  • 比如以上的age 变量，年龄大家 一般都存为数字，
1
age = int(input('输入年龄')) # 把得到的数据转换为整形再赋值给age       str为int型

转义字符

一些特殊意思的字符！！比如 暗号，

编程中,字符串里同样也有特殊意思的字符，，，即转义字符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
\n --> 换行
\t --> 制表符(tab)一般是4个空格
\\ --> 正常输出一个\
\' --> 正常输出一个引号  
\a 
print('老板说:\t大家要注意身体\'')  #老板说:	大家要注意身体'
print('老板说:\n大家要注意身体\'')
#老板说:
#大家要注意身体'    

# 有的时候.不需要一个字符串里出现转义.可以在字符串前面加个r.就会取消转义功能
print(r'晚上好\t你吃饭了么啊\n哈哈哈\a')   #晚上好\t你吃饭了么啊\n哈哈哈\a
print('晚上好\t你吃饭了么啊\n哈哈哈\a')    
#晚上好	你吃饭了么啊
#哈哈哈

作业

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1.定义一个列表,列表中有3种"数值类型",用多种方法获取里面的第二个值
2.现有一变量 phone = 1314520,把phone转换为字符串,并输出1314与520
3.现有一变量 names = "pdd陈奕迅刘德华周杰伦" 输出"pdd","奕迅","德华周杰伦"
4.现有一变量 times = "20990611" 把其中的年,月,日分别输出出来
5.现有一变量 talk="多喝热水",想办法输出"水热喝多"
6.用一个print,输出下面内容
众人    寻他千百度    
那人    却在灯火阑珊处

7.计算a, b, 相加 并打印出来 （代码题）
	a = "12"
	b = 111111111
	
8.元组可以进行修改吗（判断题）
9.列表数据不能修改（判断题）
10.字符串+数字类型可以吗（解答题）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#1.定义一个列表,列表中有3种"数值类型",用多种方法获取里面的第二个值
list=[12,"lallala",(1,2,3),False]
print(list[1])     #下标
print(list[1:2])   #切片
print(list[1:0:-1])  #切片
#2.现有一变量 phone = 1314520,把phone转换为字符串,并输出1314与520
phone=1314520
phone1=str(phone)
print(phone1[:4])
print(phone1[4:])

#3.现有一变量 names = "pdd陈奕迅刘德华周杰伦" 输出"pdd","奕迅","德华周杰伦"
names = "pdd陈奕迅刘德华周杰伦"
print(names[:3])
print(names[4:6])
print(names[7:12])
print(names[-5:])

#4.现有一变量 times = "20990611" 把其中的年,月,日分别输出出来
times = "20990611"
year=times[:4]
month=times[5:6]
print(times[7:5:-1])
days=times[-2:]
print(year,month,days)

#5.现有一变量 talk="多喝热水",想办法输出"水热喝多"
talk="多喝热水"
print(talk[::-1])

"""
6.用一个print,输出下面内容
众人    寻他千百度    
那人    却在灯火阑珊处
"""
print("众人\t寻他千百度\n那人\t却在灯火阑珊处")

"""
7.计算a, b, 相加 并打印出来 （代码题）
	a = "12"
	b = 111111111
"""
a = "12"
b = 111111111
print(int(a)+b)
#8.元组可以进行修改吗（判断题）  不能
tupe=(1,2,3,4)
#type[2]=10   #TypeError: 'type' object does not support item assignment
#9.列表数据不能修改（判断题）  #列表可以修改
list2=[1,(2,3,10),5]
list2[1]=4
print(list2)
#10.字符串+数字类型可以吗（解答题）
print("因为类型不同，所以不能相加。转化类型就可以了")

分享

序列类型的方法

八.序列类型的常用方法

上节回顾

  • 字符串 str 用单引号或者是双引号包裹的数据就是字符串 不可变类型
  • 列表 list 用中括号 [] 包裹的数据就是列表 可变类型 列表里面可以放各种数据 包括元组列表
  • 元组 tuple 用小括号 () 包裹的数据就是 元组， 不可变类型，
  • int也是不可变类型

序列类型的特点

  • 下标 门牌号，我们通过下标去拿到数据 都是 以0开始
  • 切片，[起始:结束: 步长] 取头不取尾，也就是 [0:5] 实际上 0到4 的数据

初始方法

​ 方法,eg:生活中解决的方法，方案，特定的功能

​ 比如：车出现了问题 方法 1. 去修车厂 维修 方法2 直接买新的，

​ 其实就是， 对数据的增，删，改，查， 在我们一个程序中， 经常对数据进行操作，为了提高我们的开发效率，Python为我们设置一些内置方法，

列表方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
列表的方法
li = ["jk", "韦寻", 100, "张三"]


# 增
# 1. append 添加一个数据，添加到列表的最后面
# 变量.append(数据)
 li.append("李四") #['jk', '韦寻', 100, '张三', '李四']
#  li.append("bbbb","pppppppppp")  #TypeError: append()只接受一个参数(给定2)
 print(li)

# 2.insert  添加一个数据，必须指定位置，并且原数据会被挤在后面。不加位置会报错
# 变量.insert(下标,"数据")
# li.insert(0,"阿飞")
# print(li)
li.insert(10000000000,"uuuuuuuuu")   #['阿飞', 'jk', '周杰伦', 100, '张三', 'lalalalala', 'uuuuuuuuu']
name=li.insert(100000000,"oooooooooooo") #None   insert的返回值为None
print(name)
"""
insert插入必须给位置，否则报错
insert插入的位置为负值且超过它自身长度时默认插在最前面
insert插入的位置为正值且超过它自身长度时默认插在最后面
insert插入的位置为长度范围之内时，正值从前往后，负值从后往前
当给insert插入的值赋值给另一变量时，输出为None
"""

# 3.extend 追加一个数据到最后一位，把数据打散放入

li.extend("hello world,")
print(li)#['jk', '周杰伦', 100, '张三', 'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', ',']
li.append("hello world,")
print(li)#['jk', '周杰伦', 100, '张三', 'hello world,']

li.extend([123,123,])
li.extend([123,123])
print(li) #['jk', '周杰伦', 100, '张三', 123, 123]
li.append([123,123,])
li.append([123,123])
print(li) #['jk', '周杰伦', 100, '张三', [123, 123]]

li.extend((123,123,))
li.extend((123,123))
print(li) #['jk', '周杰伦', 100, '张三', 123, 123]
li.append((123,123,))
li.append((123,123))
print(li) #['jk', '周杰伦', 100, '张三', (123, 123)]
          #['jk', '周杰伦', 100, '张三', (123, 123)]
    
li.extend(123)
print(li)#TypeError: 'int' object is not iterable可迭代的
"""
添加的值必须是序列类型   所以int不能加入  因为int不是序列类型
如果添加的列表[]  ，元组（"Hello world"，）    不会被打散
append添加带[]or(),ectend不带
无论append还是extend,(123,123,)与(123,123)输出结果一样
"""

# 删
# 1. pop 删除一个值， 也可以指定位置  默认就是删最后一位
# 变量.pop()
# 变量.pop(下标)

print(li)   #['jk', '周杰伦', 100, '张三']
print(li.pop())  #张三   pop方法返回删除值
print(li)  #['jk', '周杰伦', 100]

li.pop(1)  
print(li)   # ['jk', 100, '张三']
"""
 pop方法返回删除值
 下标越界会报错
"""

# 2. remove 删除一个值， 有多个值， 根据下标 数据删除
# 变量.remove(数据)
li1 = ["杰伦", "jk","阿飞","jk"]
# li1.remove("jk") # ['杰伦', '阿飞', 'jk']
# print(li1)
"""
若有多个相同值，根据下标小的删除
若remove一个没有的值会报错#ValueError: list.remove(x): x not in list
若remove的里面啥都不给也会报错#ypeError: remove() takes exactly one argument (0 given)
"""

# clear 直接清空 列表，
# 变量.clear()
# li1.clear()
# print(li1)  # []

# del 删除 直接干掉
# del 变量名
# del 列表名
# del 列表[下标]
del li1  #NameError: name 'li1' is not defined
del li1[1]
del li1[:1]
a = 100
del a
del li1[2] # ['杰伦', 'jk', 'jk']
print(li1)



# 改

# 下标修改
# 列表[下标] = 数据
li1 = ["杰伦", "jk","阿飞","jk"]
 #通过下标修改
li1[1] = 1    # ['杰伦', 1, '阿飞', 'jk']
li1[1]="1"    #['杰伦', '1', '阿飞', 'jk']
li1[1]=(1)    #['杰伦', 1, '阿飞', 'jk']
li1[1]=[1]    #['杰伦', [1], '阿飞', 'jk']   

# 切片修改
# 列表[起始:结束] = 数据，数据，数据
li1[1:-1]="A",1314,520
# ['杰伦', 'A', 1314, 520, 'jk']

li1[1:3]="A,B,C"      # ['杰伦', 'A', ',', 'B', ',', 'C', 'jk']
li1[1:3]="ABC"        # ['杰伦', 'A', 'B', 'C', 'jk']     打散了
li1[1:3]="A","B","C"  # ['杰伦', 'A', 'B', 'C', 'jk']
li1[1:3]=("A","B","C")# ['杰伦', 'A', 'B', 'C', 'jk']
li1[1:3]=("A,B,C")    # ['杰伦', 'A', ',', 'B', ',', 'C', 'jk']

li1[1:3]=["A","B","C"]# ['杰伦', 'A', 'B', 'C', 'jk']

li1[1:3]=["A,B,C"]    # ['杰伦', 'A,B,C', 'jk']   
li1[1:3]=["ABC"]      # ['杰伦', 'ABC', 'jk']
li1[1:3]=(A,B,C)      # NameError: name 'A' is not defined
li1[1:3]=[A,B,C]      # NameError: name 'A' is not defined



li1[1:3]=[123]#['杰伦', 123, 'jk']
li1[1:3]=123#报错
'''
修改时加不加[]输出一样，只要数据是序列，int类型li1[1:3]=123这样不行
'''
# 查

# 1.index  根据内容返回下标， 找到返回下标
# 列表.index(内容)
li2 = ["sdfs","jk", "韦寻"]
str1 = "adsb"
print(str1.index("ad"))
print(li2.index("阿飞"))
"""
如果不存在的内容报错
"""
# 其他
# sort 排序， 默认从小到大， reverse=True 才是 从大到小
# 列表.sort()

li3 = [123,12312,3,12,3,12,312,2,312,3]
li3.sort()  # [2, 3, 3, 3, 12, 12, 123, 312, 312, 12312]
li3.sort(reverse=True)  # [12312, 312, 312, 123, 12, 12, 3, 3, 3, 2]
print(li3)

元组方法

1
2
3
4
5
6
7
8
9
10
11
num = (1,212,312,1,312,31232112,121,1)

# index 根据内容返回下标  否则不存在则程序报错
变量.index()
print(num.index(1))

# count 统计数据出现的次数
变量.count()
print(num.count(1))


字符串的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
# + 拼接字符串   -不允许
str1 = "hello" + " world"
str1 += "韦寻"
print(str1) #hello world韦寻

# join 拼接字符串的 根据指定 字符连接
# seq 序列类型 元组 列表 字符串
# 变量名.join(seq)

flag = "-"
li = ("1","223","12")
print(flag.join(li))  #1-223-12
print(type(flag.join(li)))#<class 'str'>



# 删
# replace 替换
# 变量.replace("要替换的值", "")  #什么都不写则替换为空
# 变量.replace("要替换的值", "新的值")
# 变量.replace("要替换的值", "新的值", 修改的次数)

str1 = "何年今夕是何年"
print(str1.replace("何年","")) #空的字符串
print(str1.replace("何年"," "))#空格字符串
print(str1.replace("何年","2022年"))
print(str1.replace("何年","2022年",1))
print(str1.replace("何年","2022年",-1))
"""
今夕是
 今夕是 
2022年今夕是2022年
2022年今夕是何年
2022年今夕是2022年
"""

# 改
desc = " jace is boy 帅哥 "
# upper  字符串字母 变成 大写
# 变量.upper()

print(desc.upper()) # JACE IS BOY 帅哥
print(desc) #  jace is boy 帅哥 
desc=desc.upper()
print(desc) # JACE IS BOY 帅哥

# lower  字符串字母 变成 小写
# 变量.lower()
desc="JACE IS BOY 帅哥"
print(desc.lower()) # jace is boy 帅哥

# titile 单词首字母大写,    可判断空格
# 变量.title()
desc = " jace is boy 帅哥 "
print(desc.title()) # Jace Is Boy 帅哥
desc="JACE IS BOY 帅哥"
print(desc.title()) # Jace Is Boy 帅哥


# strip 去除字符串左右两边的空格   换行符号\n 也ok
# 变量.strip()
desc = " jace is boy 帅哥\n"
print(desc.strip())  #jace is boy 帅哥


# split 切分， 根据指定的内容 切分字符串
# 变量.spilt("分割对象")
desc = " jace is boy 帅哥"
print(desc.split("is")) # [' jace ', ' boy 帅哥 ']
#如果分割对象不存在  相当于list类型转化  但实际转化会被分散
desc = " jace is boy 帅哥"
print(desc.split("isqq"))#[' jace is boy 帅哥']
print(list(desc)) 
#[' ', 'j', 'a', 'c', 'e', ' ', 'i', 's', ' ', 'b', 'o', 'y', ' ', '帅', '哥']


# 查
kd = "pdd,Jay,韦寻"
# find 通过内容 找到 返回它的下标（一般返回第一个字母的下标后不在进行后面的查找）       找不到 返回-1
# 变量.find("内容")
# 变量.find("内容",起点)

print(kd.find("成龙")) # -1
print(kd.find("pdd"))  # 0
print(kd.find("pdd",3)) # -1

# count 统计数据出现的次数
# 变量.count("数据")

print(kd.count("p")) # 1

# isdigit 判断该字符串是否是纯数字  返回bool值 True False
# 变量.isdigit()

print(kd.isdigit()) # False

# isalpha 判断该字符串是否是纯字母  返回bool值 True False
# 变量.isalpha()
print(kd.isalpha())


# endswith 判断字符串的尾巴后缀.是否于指定的数据相等   返回bool值 True False
# 变量.endswith()
# 用作判断文件类型，通过后缀  .jgp .png  .mp3 .mp4 .pdf
print(kd.endswith(".jpg")) # False


# len函数   获取序列类型的长度，也可以知道 数据有几个
print(len([1,2,3,111,4]))  #  5
print(len(kd))              # 10
 

# https://www.runoob.com/python3/python3-string.html  想了解更多的内容，

小结：

split （经常会用到, 并且返回的是列表）

replace （）

这里只是一部分方法，大家也可以课后看看其他的方法https://www.runoob.com/python3/python3-string.html

提前复习的网站http://c.biancheng.net/python/

可变类型与不可变类型

  • 字符串，数字，元组都是不可变的，里面的数据是不能改变的，除非你重新赋值
  • 字符串 》》》 样品， 产品图，概念图
  • 经过 方法 》》 商品，成品

作业

  • ```python
    1.用什么方法可以知道字符串的长度

    1. 将输入的字符串反转过来
      示例 1:
      输入: “hello”
      输出: “olleh”

    3.将字符串 “abcd” 转成大写
    4.计算字符串 “cd” 在 字符串 “abcd”中出现的位置
    5.s1 = “Python is good”, 请将字符串里的Python替换成 python,并输出替换后的结果
    6.有一个字符串 s2 = “python修炼第一期.html”，请写程序从这个字符串里获得.html前面的部分，要用尽可能多的方式来做这个事情

    1. “this is a book\n”， 字符串的末尾有一个回车符，请将其删除
    2. “this is a book”,请将字符串里的book替换成apple
    3. “this is a book”, 请用程序判断该字符串是否以this开头
    4. “this is a book”, 请用程序判断该字符串是否以apple结尾
    5. “This IS a book”， 请将字符串里的字符转成小写字符

    列表
    num_li = [1,2,3,4,5]

    1.求列表的长度
    2.判断6 是否在列表中
    3.numli + [6, 7, 8] 的结果是什么？
    4.numli*2 的结果是什么
    5.列表里元素的最大值是多少
    6.列表里元素的最小值是多少
    7.列表里所有元素的和是多少
    8.在索引1的位置新增一个的元素10
    9.在列表的末尾新增一个元素20

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117


    ## 答案

    ~~~py
    # 1.用什么方法可以知道字符串的长度
    stu ="kkkiidnxjcgc"
    print(len(stu))
    """
    2. 将输入的字符串反转过来
    示例 1:
    输入: "hello"
    输出: "olleh"
    """
    #str1 = input("请输入hello")
    a = "hello"
    #print(str1[::-1])
    print(a[::-1])
    # 3.将字符串 "abcd" 转成大写
    b = "abcd"
    print(b.upper())

    # 4.计算字符串 "cd" 在 字符串 "abcd"中出现的位置
    print(b.find("cd"))
    print(b.index("cd"))

    # 5.s1 = "Python is good", 请将字符串里的Python替换成 python,并输出替换后的结果
    s1 = "Python is good"
    print(s1.lower())
    print(s1.replace("Python","python"))

    # 6.有一个字符串 s2 =  "python修炼第一期.html"，请写程序从这个字符串里获得.html前面的部分，要用尽可能多的方式来做这个事情
    s2 = "python修炼第一期.html"
    print(s2[:11])
    print(s2[:-5])
    print(s2.replace(".html",""))
    print(s2.split(".")[0])
    print(s2.strip(".html"))

    # 7. "this is a book\n"， 字符串的末尾有一个回车符，请将其删除
    s3 ="this is a book\n"
    print(s3.strip())
    # 8. "this is a book",请将字符串里的book替换成apple
    s4 = "this is a book"
    print(s4.replace("book","apple"))

    # 9. "this is a book", 请用程序判断该字符串是否以this开头
    # print(s4.find("this"))
    print(s4.startswith("this"))

    # 10. "this is a book", 请用程序判断该字符串是否以apple结尾
    print(s4.endswith("apple"))
    # 11. "This IS a book"， 请将字符串里的字符转成小写字符
    s5 = "This IS a book"
    print(s5.lower())

    print("------------------------")

    num_li = [1,2,3,4,5]

    #  1.求列表的长度
    print(len(num_li))  #5

    #  2.判断6 是否在列表中
    #print(num_li.index("6"))  # 没有会报错
    print("6" in num_li)     # False
    print(num_li.count("6")) # 0

    #  3.num_li + [6, 7, 8] 的结果是什么？
    num_li = [1,2,3,4,5]
    #print(num_li + [6, 7, 8]) #[1, 2, 3, 4, 5, 6, 7, 8]
    print("---")
    #num_li.extend([6,7,8]) #[1, 2, 3, 4, 5, 6, 7, 8]
    #print(num_li)
    #num_li.append([6,7,8]) #[1, 2, 3, 4, 5, [6, 7, 8]]
    #print(num_li)
    #num_li.insert(11,[6,7,8]) #[1, 2, 3, 4, 5, [6, 7, 8]]
    #print(num_li)
    #  4.num_li*2 的结果是什么
    print(num_li*2)  #[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
    #  5.列表里元素的最大值是多少
    print(num_li.sort(reverse=True))  #None  因为它是一个没有返回值的方法
    print(num_li[0])     #5
    print(max(num_li))   #5     # 内置函数  也就是Python自带的
    #  6.列表里元素的最小值是多少
    print(num_li.sort()) #None
    print(num_li[0])     #1
    print(min(num_li))   #1
    #  7.列表里所有元素的和是多少
    print(sum(num_li))  #15
    #  8.在索引1的位置新增一个的元素10
    print("=========")
    num_li.insert(1,10)    #[1, 10, 2, 3, 4, 5]
    print(num_li)
    #  9.在列表的末尾新增一个元素20
    print(num_li.append("20")) #None
    print(num_li)  # [1, 10, 2, 3, 4, 5, '20']
    ~~~





    ## 使用typora 做笔记的语法

    markdown 语法

    [教程](https://www.jianshu.com/p/399e5a3c7cc5)

    ## 爬虫小案例

    安装模块

    ```python 
    pip install html5lib -i https://pypi.tuna.tsinghua.edu.cn/simple
    pip install requests -i https://pypi.tuna.tsinghua.edu.cn/simple
    pip install lxml -i https://pypi.tuna.tsinghua.edu.cn/simple

九.格式化输出&字符编码

上节回顾

序列类型的方法

  • 列表
  • 元组
  • 字符串
  • 作业讲解
  • max() 求最大值
  • min() 求最小值
  • sum() 求和

格式化输出

从字面意思看，就是按照一定的格式的输出

生活中的，信件的格式，作文的格式，短信的格式等等

1
【某团】短信验证码：xxxx

%操作符 （占位符）

在程序中，看到了%这样的操作符，这就是Python中格式化输出。

注意：int类型可以作为str型，但str不能作为int型。

格式符号 转换
%f 浮点数 小数
%s 字符串
%d 有符号十进制整数 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
语法：
	print("xxx%dxxx" % 数据)
    print("xxx%sxxxx%d" % (数据1，数据2))
	
    
案例：
age = 18
name = "xiaohua"
money = 100.5687
print("我的姓名是",name,"年龄是",age,"存款是：",money)
print("我的姓名是%s, 年龄是%d 存款：%f" % (name, age, money))
print("我的姓名是%s, 年龄是%d 存款：%f" % (age, age, money))
#print("我的姓名是%s, 年龄是%d 存款：%f" % (name, name, money))  
#TypeError: %d format: a number is required, not str
## 保留两位小数 %.2f
print("我的姓名是%s, 年龄是%d 存款：%0.2f" % (name, age, money))  #%0.xf或者%.xf就是保存几位，四舍五入  如果是1或者2或者其他整数都一个结果，有没有无所谓
print("今天天气%s, 气温：%d度" %("热", 28))
"""
我的姓名是 xiaohua 年龄是 18 存款是： 100.5687
我的姓名是xiaohua, 年龄是18 存款：100.568700
我的姓名是18, 年龄是18 存款：100.568700
我的姓名是xiaohua, 年龄是18 存款：100.57
今天天气热, 气温：28度
"""
总结:
    前面有几个，后面就要有几个 并且要匹配（一一对应）
    保留x位小数 就写%.xf

format用法

1
2
3
4
5
6
7
8
语法:
    'XX{}XX{}'.format(数据1,数据2) 			# 传入的数据类型是不限的,
    'XX{下标}XX{下标}'.format(数据1,数据2) 
案例:
    print('大家好,我叫{},我今年{}岁了.'.format(name,age))
    print('大家好,我叫{1},我今年{0}岁了.'.format(age,name))
    print('你好,我是{},今天是{}号，身高{}米'.format('李四',14,1.78))
    print('你好,我是{2},今天是{0}号，身高{}米'.format('李四',14,2.20))

小结：

format 的占位问题 可以通过下标进行占位 并且数量可以不一致， 也就是不用一一对应

但写下标就得全写,不可以有的写有的没写

f-str 用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
最简单粗暴的格式化输出方式
语法: 在字符串前面加f/F,把要输出的变量用{}包裹起来

	f'XXX{变量}XXX{}'
    F'XXX{变量}XXX{}'
案例：

	name = "阿飞"
    num = 10
    height = 1.78
    print(f'大家好,我叫{name},今天{num}号')
    print(f'大家好,我叫{name},今天{num + 1}号')  #python创始人 gui叔
    print(f'大家好,我叫{name},今天{float(num)}号')
	print(f'大家好,我叫{name},今天{name.count("12")}号')
    print(f'大家好,我叫{name},今天{num +1}号 身高{height:.4f}')
	
    """
	大家好,我叫阿飞,今天10号
	大家好,我叫阿飞,今天11号
	大家好,我叫阿飞,今天10.0号
	大家好,我叫阿飞,今天0号
	大家好,我叫阿飞,今天11号 身高1.7800
    """
    
小结：
    大括号里面的变量,是可以进行操作的 包括数值运算, 方法等

字符编码

计算机在处理字符的时候，他需要用一本字典进行翻译也就是字符集、字符编码,字典中的字符没有你要显示的字，那输出的就是乱码

那第一套编码Ascll，美国弄出来的，里面没有汉字，那我们想输出的汉字，怎么办，

把汉字编进去，我们自己的编码gb2312 台湾繁体字 big5

目前最流行的字符编码 utf-8 对很多国家的语言文字，收集在一起，所以对其他语言文字，支持比较好，这就是大家都爱用的原因

ascll对照表 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# ascll对照表 http://c.biancheng.net/c/ascii/

# 编码问题
a = '朋友们，晚上好'
b = a.encode() # 编码 把a的数据转为一个处理后的二进制字符串
#print(b)#bin二进制
#b'\xe6\x9c\x8b\xe5\x8f\x8b\xe4\xbb\xac\xef\xbc\x8c\xe6\x99\x9a\xe4\xb8\x8a\xe5\xa5\xbd'

c = a.encode(encoding = 'GBK') # 把a以gbk的方式来转码  电脑默认是gbk方式解码
#print(c)
#b'\xc5\xf3\xd3\xd1\xc3\xc7\xa3\xac\xcd\xed\xc9\xcf\xba\xc3'

d = b.decode()  # 解码
print(d)  #朋友们，晚上好
f = c.decode(encoding = 'GBK')
print(f)   #朋友们，晚上好
#ord(字符) --> 通过字符,找到序号ascll
#chr(序号) --> 通过序号,找到字符
print(ord("a"))  #97
pr

编程语言之进阶

编程语言我们可以从不同维度进行分类，高低的维度，翻译的维度

高低的维度：

高级语言：站在人的角度，用人类的字符去编写程序，人类可以理解，而计算机需要通过翻译才能理解

高级：高层，开发者不需要考虑硬件的细节，开发效率可以大大提高，所以说编程语言是高级语言

低级语言：从计算机角度，说计算机能理解的语言

低级：比较贴近底层，硬件，内存等这些东西，需要了解计算的硬件细节，直接控制硬件

按照翻译方式的不同，来区分的，编译型，解释型

解释型：

在程序运行之前，通过解释器对程序进行翻译然后再执行

Python javascript

编译型

在程序运行之前，通过编译器将源码变成计算机能够理解的语言

C语言

demo：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
有一本英文名著 ，我们现在要来读它
	1. 方法1. 整本书翻译 也就是 读一本中文版名著
    2. 方法2  老师，想挑战一下自己，还是读英文名著，但是老师现在手里有一本英语词典，读一句，我们翻译一句，
    这样我们也能读懂
    
方式1 对应的编译型语言  
方式2 对应的解释型语言


编译型和解释型的优缺点
编译型
	优点：运行速度快，代码效率高，编译后的程序不能够修改，保密性比较好
    缺点：可移植性差，只能在兼容的系统上运行

人话：整本翻译的书，读起来肯定快，又快又好，但是只能给中国人读，日本人想读只能重新翻译一本
    
    
解释型：
	优点：可移植性好，只要有解释器环境就可以运行程序
    缺点：保密性差，效率低，运行的时候需要解释器环境，占用大量的资源
    
人话：拿着字典一句一句的翻译，虽然读起来慢，但是只要有对应的语言字典，哪个国家的人都可以读

1654780889919

作业

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1. 代码如下, 那么大家发现 重复输出了 “今天xx号”, 怎么简化程序
    print("今天11号")
    print("今天12号")
    print("今天13号")

2. 用格式化输出自我介绍(用哪种方法都可以)效果如下：
	----------自我介绍----------
    >>>>>姓名：阿飞>>>>>
    >>>>>年龄：18>>>>>
    >>>>>性别：男>>>>>
    >>>>>住址：广州>>>>>


3. 字符编码目前流行的是——————。（填空题）
    
4. 用utf-8编写的py程序，用gbk编码打开可以吗  （判断题）

5. 
    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
"""
1.
代码如下, 那么大家发现
重复输出了 “今天xx号”, 怎么简化程序
print("今天11号")
print("今天12号")
print("今天13号")
"""
a=11
print(f"今天{a}号,今天{a+1}号,今天{a+2}号")
"""
2.
用格式化输出自我介绍(用哪种方法都可以)
效果如下：
----------自我介绍 - ---------
>> >> > 姓名：阿飞 >> >> >
>> >> > 年龄：18 >> >> >
>> >> > 性别：男 >> >> >
>> >> > 住址：广州 >> >> >
"""
name = "阿飞"
age = 18
sex = "男"
addr = "广州"
print(f"---------自我介绍--------\n>> >> > 姓名：{name} >> >> >\n>> >> > 年龄：{age} >> >> >\n>> >> > 性别：{sex} >> >> >\n>> >> > 住址：{addr} >> >> > ")

str1="-"
str2=">"
print(f"{str1*10}自我介绍{str1*10}")
print(f"{str2*8} 姓名：{name}{str2*8}")
print(f"{str2*8} 年龄：{age}{str2*8}")
print(f"{str2*8} 性别：{sex}{str2*8}")
print(f"{str2*8} 住址：{addr}{str2*8}")
# 3.字符编码目前流行的是——————。（填空题）
# utf-8

# 4.用utf - 8编写的py程序，用gbk编码打开可以吗  （判断题）
#NO
"""
今天11号,今天12号,今天13号
---------自我介绍--------
>> >> > 姓名：阿飞 >> >> >
>> >> > 年龄：18 >> >> >
>> >> > 性别：男 >> >> >
>> >> > 住址：广州 >> >> > 
----------自我介绍----------
>>>>>>>> 姓名：阿飞>>>>>>>>
>>>>>>>> 年龄：18>>>>>>>>
>>>>>>>> 性别：男>>>>>>>>
>>>>>>>> 住址：广州>>>>>>>>
"""

扩展

计算机的组成

  1. 什么是计算机
    计算机俗称”电脑“，我们人类想要它像大脑一样工作，这是我们的最终目标（人工智能） 感兴趣 去看 模仿游戏 黑客帝国

  2. 为什么要有电脑
    就是为了解放人类，让它替我们干活，

    ​

  3. 计算机的组成
    控制器 运算器 存储器 输入 输出

    计算机的组成可以想象为我们人体的一部分，某一功能或者器官

    • 控制器
      作用：是计算机的指挥系统，负责控制计算机所有其他组件如何工作的#(下命令)
      类比：控制器 ==》大脑

    • 运算器
      作用：数学运算(加减乘除)与逻辑运算(判断)#(思考)
      类比：控制器==》大脑

    • 控制器+运算器==》CPU ==》人类的大脑
      #串联：点外卖：记忆 走路：大脑控制手脚 手脚动起来：控制器 老板说够了吗？找多少钱？数学计算：运算器

    • 存储器/IO设备
      作用：是计算机的记忆功能，负责数据的存取
      分类：
      #存取的例子：例如叫别人带东西，别人记住即为存，然后别人告诉商家的东西名即为取。
      内存(基于电工作):存取数据都快，断电数据丢失，只能临时存取数据#（临时记忆）
      外存(硬盘，基于磁工作):存取速度都慢，断电数据也不丢，可以永久保存数据#（跟用笔记和字条记起来一样的永久保存的记忆）
      类比：
      内存===》人类的大脑的记忆功能
      外存===》人的笔记本
      数据真的要用，一定是先从硬盘放到内存中来，内存交给CPU#老板发布任务 任务的内容就是数据比如，叫你扫地啊，端茶啊，这是不是数据，如果老板发的任务很多，我们会先记起来（字条，永久存储数据，例如外存，内存：记忆功能，记住发布的任务，要做什么什么，自己一个人念念念，念得过程肯定是先到大脑，然后让大脑念出来）

    • 输入input设备：
      如键盘，鼠标

    • 输出output设备
      显示器 打印机

    • ```python
      例子：
      cpu是人的大脑，负责控制全身和运算
      内存是人的记忆，负责临时存储
      硬盘是人的笔记本，负责永久存储
      输入设备是耳朵或眼睛或嘴巴，负责接收外部的信息存入内存
      输出设备是你的脸部(表情)或者屁股，负责经过处理后输出的结果
      以上所有的设备都通过总线连接，总线相当于人的神经（电线=人的神经）

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36

        - 与运行程序相关的三大核心硬件#（与所有核心运算都挂上关系） 我们编写的程序一定是要运行于计算机硬件之上，而站在硬件的角度，与运行程序有关的三大核心硬件为 CPU、内存、硬盘 程序最先是存放于硬盘中的，程序的运行是先从硬盘把代码加载到内存中，然后cpu从内存中读取指令运行

        - 程序比喻为   行为让小狗去捡球 捡球就是一件事情，捡球是发生在小狗身上的，

      ### cpu 知识

      - pc 主流 CPU这里我们分为 英特尔 和 amd

      - 英特尔

      - > 人人皆知，一直在挤牙膏，提升的不是很多，导致买新的CPU，还是去年的CPU，差距不是很大
        >
        >  i9 --> i7 --> i5 -->i3 --> 奔腾 --> 赛扬 AMD(锐龙)

      - AMD

      - > 这几年经过苏妈( 苏姿丰 )的领导，对性能的释放以及版本性能提升都比 起Intel亮眼很多.所以有个梗 AMD YES!(表示对AMD产品的认可) 

      - ![1666360980852](D:/05格式化输出/%E6%A0%BC%E5%BC%8F%E5%8C%96%E8%BE%93%E5%87%BA%E4%B8%8E%E5%AD%97%E7%AC%A6%E7%BC%96%E7%A0%81.assets/1666360980852.png)

       购买参考指标:
          ``主频,缓存,多级缓存,核数,线程数
        ``常见故障:
          ``CPU温度过高导致死机,重启.(天气,散热老化,长时间运行,超频) --> 清灰或换散热器
        ``型号解析:

      ```python
      ``i7-12875H --> i7表示的是架构版本
                       ``12表示的是第十二代
                       ``875表示性能指数
                       ``H表示标压处理器(性能较强,续航较弱)
        ``R5-6600U --> R5表示的是架构版本 
                   ``6代表第六世代
                   ``600表示性能指数
                   ``U代表低压处理器(性能较弱,续航较强)
1
2
3
4
5
CPU会分为 好几个架构:
    ``i3/r3 --> 入门机型用的cpu.性能偏弱
    ``i5/r5 --> 标准,性能OK
    ``i7/r7 --> 高性能
    ``i9/r9 --> 极致性能

CPU天梯图

1
2
3
4
5
``tips:
   ``1.一般情况下数字越大越牛(看整体数字,不是单纯看架构版本.新版本i5/标压的i5性能可能会比上版本/低压i7强).
   ``2.低压处理器(性能弱,续航强)标压处理器(性能强,续航弱) 
   ``3.游戏需求+大型软件需求(标压) 日常办公使用(低压)
   ``4.如果实在不了解信息,可搜索最新版本的"CPU天梯图"里面有性能排行

硬盘知识

1
2
3
4
5
6
7
8
9
10
``硬盘主要用作于存储数据.,负责永久性数据存储,速度相较于CPU慢
 ``因存储方式不同区分为 
     ``机械硬盘(HDD):
       ``速度慢,容量大,较便宜
     ``固态硬盘(SSD):
       ``速度快,容量小,较贵些,适合读多写少
     ``购买参考指标:
       ``容量,缓存,转速,读写速度,尺寸(笔记本和台式机用的硬盘尺寸是不同的,购买时需要注意),固态接口类型(M.2接口,SATA接口)
 ``推荐就是固态+机械 --> 固态作为系统盘,机械做些存储盘
 ``计算机里面一些程序的运行速度跟加载速度有关.所以可以把一些常用的软件,游戏放到固态硬盘中

内存条

1
2
3
4
5
6
7
8
9
10
11
``这里的内存指的是"运行内存",也是用于存储数据,主要存储临时数据,关机后清空,相较硬盘,存储速度更快.
``内存的好坏也是直接影响了电脑的使用效率,速度.
``电脑在开机后,会把常用数据从硬盘先读入内存,方便后续CPU使用,提高执行效率.
``数据读写顺序:
  ``CPU --> 内存 --> 硬盘
``在开发工作时,内存使用率达到80%就需要加内存了.学编程,8G内存打底,
最好是16G
 
  ``1.购买时要注意是否和主板相匹配
  ``2.加装时,最好购同品牌,同频率产品.避免兼容问题
  ``3.购买笔记本时,注意是否支持加装内存条

十.复习拓展

pycharm安装

1657627505735

1657627539686

1657627671338

1657627724879

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
ide: 集成开发环境 --> 有很多家伙的作案工具
        编辑器: 给你写代码,修改代码的地方
        编译器: 帮你运行代码的工具
        调试器: 帮助你检查bug,了解程序运行流程的工具
        其他工具: 杂七杂八.git上传,窗口句柄工具,远程连接工具等等.
idle --> idle其实就是在ide的基础上加了个l   learing --> 集成开发学习环境
     
    idle主要是给学习使用的,作为学习工具完全OK,作为开发工具.没那么完善
    pycharm --> 目前最主流最好用的python开发工具
    pycharm -->  下载渠道
        1.官网下载 (https://www.jetbrains.com/pycharm/) 国外 
        2.网上搜索
        3.课件网盘
    pycharm版本说明:
        1.专业版 --> 有更多的功能.但是需要付费/激活账号
        2.社区版 --> 免费,功能也够用了
    教学使用的为pycharm2021社区版

    pycharm是不能运行python代码的. 我们在pycharm中要运行py程序时,pycharm就会找到python环境,紧急请求支援6

    快速注释的快捷键 --> 选择代码 ctrl + /
    快速复制上一行代码 --> ctrl + d

1657628134154

1657628180908

1657628251924

1661948497159

1657628314193

复习 & 如何做笔记

1
2
3
4
5
print("小星星")  # 人想说话  print 
print(说出的内容)
na = input("请输入账号，")  # 返回的就是str 类型
input()  # 获取我们键盘的数据 
print(na)

数据类型与变量

1
2
3
4
5
6
7
8
9
10
11
12
int 123  21312123 99999
float 3.14  1.5  3.6
bool  True(真) \ False(假)

变量 = 值  
# 变量其实就是菜篮子，存储多个数据，或者一个数据

# 变量名的规则，数字+字母+下划线 且数字不能开头，
# 不能与关键字重名
# 驼峰命名法
# 见面知意

序列&序列类型的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
# 序列类型
## 序列类型的特点是 有序的数据类型，可以通过下标找到它



## str 字符串  不可变类型
## 用单引号或者双引号包裹的数据
str1 = "众人寻我千百度，那人却在灯火阑珊处"

## list
## 用[]包住的数据，就是列表  可变类型
li1 = [123,"ssdfds"]
li2 = []

## tuple 元组 # 不可变 ， 存放不想修改的数据
## 用()包裹的数据， # 只有一个数据，也要加上逗号
tu1 = (80,)



## 下标& 切片
### 下标 是  生活类似门牌号的东西，
下标 默认是从0开始

### 切片 
[起始:结束:步长]
取头不取尾  [0:5] 0到4



# list  列表 方法
# 增
append   # 把数据 列表的最后面
insert   # 参数1 下标  参数2 数据
extend   # 打散数据  只能添加序列类型

# 删
pop  	# pop 默认 删最后一位    写上下标 就根据下标
remove  # 根据数据删除
del     # del 什么都可以删  删变量名  删list[1] 
clear 	# 清空列表


# 改
list1[下标] = 数据1，

# 查
index()  # 找不到就会返回报错  找到就会下标 

# 排序
sort()    	# 从小到大
sort(reverse=True)  # 从大到小


# str 方法
#增
+ 拼接
join 拼接 根据指定 字符连接

# 删
replace  替换 	# 参数1替换数据   参数2 新数据  	参数3 替换次数

# 改
# upper  字符串字母 变成 大写
lower 字符串字母 变成 小写
title  单词首字母大写, 判断空格
strip 去除字符串左右两边的空格 换行\n
split 切分， 根据指定的内容 切分字符串  # 返回 list 列表
# 查
find 通过内容 找到 返回它的下标 找不到 返回-1
count 统计数据出现的次数
isdigit 判断该字符串是否是纯数字  返回bool值 True False
isalpha 字符串是否是纯字母  返回bool值 True False
endswith 判断字符串的尾巴后缀.是否于指定的数据相等   返回bool值 True False

len函数 》》 获取序列类型的长度，也可以知道 数据有几个

## 元组方法

index 找不到就会返回报错
count 统计数据的次数


# 格式化输入

# %操作符
# str   %s 
# float  %f		2位小数	%.2f  3位小数 %.3f
# int    %d


# format 
print("我叫{}，年龄{}".format("jk",23))
print("我叫{1}，年龄{0}".format("jk",23))


# f-str
name = "韦小宝"
age = 99999
print(f"我叫{name}，年龄{age}")
print(f"我叫{name.strip()}，年龄{age + 1}")


爬虫案例（爬取音乐）

核心是搞清楚如何爬取，三个字 》》》 找规律

代码其实不难，难在于你如何理解，这里听懂的同学 扣 1

理解老师是如何发现这个《规律》以及通过哪些方式 ，

1
2
3
- 观察url     https://music.163.com/   https://www.baidu.com/
- 观察返回的什么
- 看看页面里面有没有

那么今晚就说明你听懂了

讲解 pip 到底是什么

1
2
3
4
5
6
7
8
9
10
11
12
13
14
pip 是我们Python管理包的工具  >>    手机的手机商店
install 安装的意思		    >>   手机商店的下载
uninstall  卸载的意思， 不想要这个包了，就用它      >>  卸载
-i 加速源   因为包也是网上下载，下载下来的，那就会有网速快慢的问题， 
    这里有人 给我们 安排几个 网站，也是可以下载 的
    比如 清华源  清华自己的网站
        清华：https://pypi.tuna.tsinghua.edu.cn/simple
        阿里云：http://mirrors.aliyun.com/pypi/simple/
        中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple/
        华中理工大学：http://pypi.hustunique.com/
        山东理工大学：http://pypi.sdutlinux.org/ 
        豆瓣：http://pypi.douban.com/simple/
            
 pip uninstall requests
  • 模块安装

pip install 模块名 -i 加速源
pip install html5lib -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install requests -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install lxml -i https://pypi.tuna.tsinghua.edu.cn/simple

代码文件 jianyiNetMusic.py

http://cxy521.com/python.html 程序员万能库

十一.散列类型 字典&集合

之前学过的数据类型有

  • 数值类型： int / flloat / bool 存储一个数值数据
  • 序列类型：str/ list / tuple 存储多个数据， 有序，下标，切片

散列类型：

  • 存储多个数据，无序，数据不重复

初识集合(set)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
集合(set) --> 是一个可以存(不重复)且{无序存储}的容器.主要用来进行去重和逻辑判断
 
    用大括号{}包裹起来的数据(元组，数字，字符串),里面的数据用逗号隔开
    语法:
        集合名 = {数据1,数据2}
        s1 = {"3","1",123}
 
    如果检测到有重复数据,那么集合就不会把重复的数据放入到自己的存储空间即自动去重
     
    set1 = {12312,12312,123,111}
    print(set1) # 正常输出一个集合,里面的重复元素都被去除掉,自动去重
    # 12312,123,111
    #print(set1[2]) # 报错,因为散列类型没有下标的概念
    print(type(set1)) # 查看数据的类型
 
    进行逻辑运算,集合的运算:
        集合1 & 集合2 --> 获取交集
        集合1 | 集合2 --> 获取并集
        集合1 - 集合2 --> 获取差集
 	    集合1 ^ 集合2 --> 获取对称差集
    & --> shift + 7
    | --> shift + \
    - --> 减号
    ^ --> shift + 6
 
    交集 --> 一个数据,两个集合里都有
    并集 --> 两个集合里的所有数据(不算重复的)
    差集 --> 一个集合-另一个集合.剩下的就是它独有的
    对称差集 -->  返回各自独有的
    
   	生活例子：小明，小华 去商店买东西
    xi_ming = {"可乐","辣条","鸡爪"}
    xi_hua = {"可乐", "面包", "qq糖"}
   
 	# 交集：
    print(xi_ming & xi_hua) # 可乐
    # 并集：
    print(xi_ming | xi_hua) # {'可乐', 'qq糖', '辣条', '面包', '鸡爪'}
    # 差集:
    print(xi_ming - xi_hua) # {'辣条', '鸡爪'}
    
    # 对称差集
    print(xi_hua ^ xi_ming) # {'qq糖', '面包', '鸡爪', '辣条'}
    
    
    #利用集合去重特性 实现----->列表快速去重  案例
    li = [123,123,123,"jk"]
    print(list(set(li)))   #[123, 'jk']

小结：

集合可以用于去重，

进行 逻辑判断，集合运算，交并差以及对称差集

set的方法

添加元素

集合是用大括号{}包裹起来的数据(元组，数字，字符串) 注意：没有列表

1
2
3
4
5
6
7
8
9
add 增加一个数据  添加的数据不能是列表
	集合名.add(数据1)
	set1.add(1314)
a = {12,11,3}
a.add(123)      # {3, 123, 11, 12}
a.add([11,3])   # TypeError: unhashable type: 'list'
a.add("11,3")   # {3, 11, 12, '11,3'}
a.add((11,3))   # {3, 11, 12, (11, 3)}
print(a)

删除元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
pop  删除一个数据   随机删除
    集合名.pop()
    set1.pop()

remove: 删除指定的数据  如果删除一个不存在的数据就会报错
    集合名.remove(数据)
    set1.remove(8)
    
discard: 删除指定的数据 升级版remove ：删除一个没有的数据 会显示None
    集合名.remove(数据)
    set1.remove(8)
a = {12,11,3}
a.pop()
a.remove()
a.discard(123)
a.discard(12)  
print(a)

更新元素

1
2
3
4
5
6
7
8
9
10
11
12
13
update: 把一个序列类型数据,打散添加到集合里  如果不想打散 可以再加个元组（）注：元组内一个元素时加逗号，
       update的是一个str型，则打散去重
       update的是一个元组tupe型，则把tupe的括号内的分别加入
       updata的是一个列表list型，则把list的[]内的分别加入
集合名.update(序列类型)
set1 = {12312,12312,123,111}
# set1.update('拼多多')  # {'多', 111, 12312, 123, '拼'}    
# set1.update(('拼多多')) # {111, '拼', '多', 12312, 123}
# set1.update(('拼多多',))# {12312, 123, '拼多多', 111}
set1.update(('拼多多',1314,"qqqqqqqq")) # {1314, 'qqqqqqqq', 111, '拼多多', 12312, 123}
# set1.update(['拼多多']) #{12312, '拼多多', 123, 111}
set1.update(['拼多多',1314]) #{1314, '拼多多', 111, 12312, 123}
print(set1)

初识字典(dict)

字典从字面理解，类似我们生活中的“新华字典”

根据一个字，找到它的理解

帅：形容一个人好看，靓仔

美：形容一个人漂亮，靓女

属性名：描述

键名：值

字典是 无序、键不重复且元素只能是键值对的可变的容器。

1
2
3
4
用大括号'{}'包裹起来的数据,数据的存储方式为键值对,数据之间用逗号隔开.主要用来存储一些带有'说明'性质的数据.
    字典里的值.啥数据都能放.比如数值类型可以,列表,元组也可以.甚至可以字典里面再放一个字典作为值.
    
    但是，键的类型为不可变类型，所以只能是元组 字符串 数字    不能是可变的  列表 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
格式：
    字典名 = {键1:值1,键2:值2}
    dict1 = {"name":"韦寻", "age":19,"addr":"广州" } 

输出方式：
	print(dict1)  #{'name': '韦寻', 'age': 19, 'addr': '广州'}
获取name键的值
   	print(dict1["name"])  #韦寻
修改方式：
	dict["name"] = "韦小宝"    # # {'name': '韦小宝', 'age': 19, 'addr': '广州'}
    
 例子：
dict1 = {"name":"韦寻", "age":19,"addr":"广州" }
print(dict1) #{'name': '韦寻', 'age': 19, 'addr': '广州'}
print(dict1["name"])  # 韦寻    打印值
dict1["name"] = "韦小宝"    # 修改键值
print(dict1)   # {'name': '韦小宝', 'age': 19, 'addr': '广州'}
    
键名：键名可以是数字，元组，字符串    但是列表 集合不可以   因为列表 集合是可变的，只能对不可变类型进行Hash。（value中可以放任何类型的）
       如果根据键名获取value时，输入的键名不存在，则会报错
字典的特性：
	1. 以键值对的方式存储数据，（不能只有其一）不是下标索引
    2. 键名是唯一的  （如果重复 会以最后一个为准）
    3. 不可以通过值去修改键
    
比其他类型的结构清晰，可以存对应关系，可读性比较好

声明空变量

1
2
3
4
5
6
``li1 = [] # 声明一个空列表
``tu1 = () # 声明一个空元组
``tu1 = (，) #报错 无效的数据
``str1 = '' # 声明一个空的字符串   不能加空格
``dict1 = {} # 声明一个空的字典 因为字典用的比集合多,所以默认是字典
``set1 = set() # 声明一个空集合

字典的方法

1
2
3
4
5
6
wukong = {
    "姓名":"悟空",
    "年龄":10000,
    "身高":223,
    "赛亚人": 9，
}

增：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
setdefault:给字典添加一个数据，如果这个数据已存在，就输出它的值。如果不存在  就新增一个键值对
    setdefault(键名,值)
    字典名.setdefault("儿子","孙悟饭")     新增一个键
    
print(wukong.setdefault("儿子","孙悟饭"))  # 孙悟饭  返回的value值
print(wukong) #{'姓名': '悟空', '年龄': 10000, '身高': 223, '赛亚人': 9, '儿子': '孙悟饭 
print(wukong.setdefault("儿子","孙悟天"))  #孙悟饭
print(wukong)  #{'姓名': '悟空', '年龄': 10000, '身高': 223, '赛亚人': 9, '儿子': '孙悟饭'}

print(wukong.setdefault("爸爸","孙悟饭"))  #孙悟饭
print(wukong)  #{'姓名': '悟空', '年龄': 10000, '身高': 223, '赛亚人': 9, '儿子': '孙悟饭', '爸爸': '孙悟饭'}

print(wukong.setdefault("精斗云"))  # 没有写上 value值 ，默认为None
print(wukong) #{'姓名': '悟空', '年龄': 10000, '身高': 223, '赛亚人': 9, '精斗云': None}

print(wukong.setdefault("姓名"))  # 悟空

删：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
pop 通过键名删除指定的数据  返回 删除的值  如果删除的键名不存在会报错
	字典名.pop(键名)
	print(wukong.pop("qqqq"))  #KeyError: 'qqqq'
	print(wukong.pop("姓名"))  # 悟空
	print(wukong)   #{'年龄': 10000, '身高': 223, '赛亚人': 9}


popitem: 随机删除键值对  因为字典是无序的 （如果数据字典数字比较少时 一般删除最后一位）
    字典名.popitem()
    wukong.popitem()
    
	print(wukong.popitem())  # ('赛亚人', 9)   并且以元组形式返回
	print(wukong)   #{'姓名': '悟空', '年龄': 10000, '身高': 223}
    

clear 清空字典
	字典名.clear()
    wukong.clear()
    
	print(wukong.clear())  #None
	print(wukong)    #{}
    
del 根据键名来删除  （和列表类似，列表del时通过下标删除）

	del wukong["赛亚人"]
	print(wukong)   #{'姓名': '悟空', '年龄': 10000, '身高': 223}

改: 重点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
wukong = {
    "姓名":"悟空",
    "年龄":10000,
    "身高":223,
    "赛亚人": 9，
}

update: 有则，修改键的值, 没有，就新增一个 （setdefault:有则输出它的值。没有就新增一个键值对
    
    字典名.update({键:值})
    wukong.update({"姓名":"韦小宝"})
    增加多个
    字典名.update({键:值, 键2:值2})
    wukong.update({"地址":"赛亚星","攻击力":999999})
    
    print(wukong.update({"姓名":"韦小宝"}))   #None
	print(wukong) # {'姓名': '韦小宝', '年龄': 10000, '身高': 223, '赛亚人': 9}
    
    print(wukong.update({"地址":"赛亚星","攻击力":999999}))   #None
	print(wukong) # {'姓名': '悟空', '年龄': 10000, '身高': 223, '赛亚人': 9, '地址': '赛亚星', '攻击力': 999999}

查：重点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
通过键值对的方式查:(不存在的键会报错)
    name=wukong["姓名"]
	print(name)  #悟空
get：通过键名.获取键的值，不存在这个键，返回None，不会报错
	字典名.get(键名)
    wukong.get("姓名")
    name = wukong.get("姓名1")
	print(name)  # None
    name = wukong.get("姓名")
	print(name)  # 悟空
keys: 获取所有的键
    字典名.keys()
    wukong.keys()
    
    rest = wukong.keys()
	print(rest)  # dict_keys(['姓名', '年龄', '身高', '赛亚人'])
	print(list(rest))  #['姓名', '年龄', '身高', '赛亚人']
    
items: 获取所有的键值对
    字典名.tiems()
    wukong.items()
    
    rset = wukong.items() # dict_items([('姓名', '悟空'), ('年龄', 10000), ('身高', 223), ('赛亚人', 9)])  
                          # <class 'dict_items'>
	rest = wukong.keys() # dict_keys(['姓名', '年龄', '身高', '赛亚人'])   
    				    # <class 'dict_keys'>

    
    print(list(rset))  #[('姓名', '悟空'), ('年龄', 10000), ('身高', 223), ('赛亚人', 9)]
	print(type(rset))  #<class 'dict_items'>
	print(list(rset)[0][0])  #姓名
    print(list(rset))   # [('姓名', '悟空'), ('年龄', 10000), ('身高', 223), ('赛亚人', 9)]
	print(list(rset)[2][0])  #身高

作业

    1. 对li 去重 li = [123,123,12,23,121,56,1,2,3]
    1. 用字典存储自己的自我介绍 姓名，年龄，身高，优点 等等，并进行增删改查操作

    1. 对以下两个集合进行 交集，并集，差集，处理

      animal1 = {“小猫”,”小狗”,”小鸟”}

      animal2 = {“小猪”,”小狗”,”小鸟”}

      1
      2
      3
      4
      # 1. 对li 去重  li = [123,123,12,23,121,56,1,2,3]

      li = [123,123,12,23,121,56,1,2,3]
      print(list(set(li)))    #[1, 2, 3, 12, 23, 56, 121, 123]

      1. 用字典存储自己的自我介绍 姓名，年龄，身高，优点 等等，并进行增删改查操作

      con = {“姓名”:”言沫沫”,”年龄”:”10000”,”身高”:280,”优点”:”好学创新”}
      print(con)
      #增
      print(con.setdefault(“座右铭”,”自己选择的路跪着也要走完！”)) #自己选择的路跪着也要走完！
      print(con) # {‘姓名’: ‘言沫沫’, ‘年龄’: ‘10000’, ‘身高’: 280, ‘优点’: ‘好学创新’, ‘座右铭’: ‘自己选择的路跪着也要走完！’}
      #删

      print(con.pop(“身高”)) # 280

      print(con.popitem()) # 随机删

      print(con.clear()) # None

      print(con) # {}

      del con[“身高”]

      print(con) # {‘姓名’: ‘言沫沫’, ‘年龄’: ‘10000’, ‘优点’: ‘好学创新’, ‘座右铭’: ‘自己选择的路跪着也要走完！’}

      #改
      print(con.update({“身高”:”800”})) # None
      print(con) # {‘姓名’: ‘言沫沫’, ‘年龄’: ‘10000’, ‘身高’: ‘800’, ‘优点’: ‘好学创新’, ‘座右铭’: ‘自己选择的路跪着也要走完！’}

      #查
      print(con[“座右铭”]) # 自己选择的路跪着也要走完！
      print(con.get(“name”)) # None
      print(con.get(“姓名”)) # 言沫沫
      print(con.keys()) # dict_keys([‘姓名’, ‘年龄’, ‘身高’, ‘优点’, ‘座右铭’])
      print(con.values())# dict_values([‘言沫沫’, ‘10000’, ‘800’, ‘好学创新’, ‘自己选择的路跪着也要走完！’])
      print(con.items()) # dict_items([(‘姓名’, ‘言沫沫’), (‘年龄’, ‘10000’), (‘身高’, ‘800’), (‘优点’, ‘好学创新’), (‘座右铭’, ‘自己选择的路跪着也要走完！’)])

      1. 对以下两个集合进行 交集，并集，差集，处理

      animal1 = {“小猫”,”小狗”,”小鸟”}

      animal2 = {“小猪”,”小狗”,”小鸟”}

      print(“交集”,animal1 & animal2) # {‘小狗’, ‘小鸟’}
      print(“并集”,animal1 | animal2) # {‘小狗’, ‘小鸟’, ‘小猪’, ‘小猫’}
      print(“差集”,animal1 - animal2) # {‘小猫’}
      print(“对称差集”,animal1 ^ animal2) # {‘小猫’, ‘小猪’}
      ~~~

      ​

360 使用了查毒，就把它退了，长期占用

注册表 电脑管家， 360 处理垃圾，把他退掉

课后巩固

课前预习

http://c.biancheng.net/python/flow_control/ 流程控制语句 有一点逻辑性的东西

分水岭

压缩软件

n

​

​

​

​

赏

谢谢你请我吃糖果

支付宝
微信
置顶

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家