二、python基础语法篇(黑马程序猿-python学习记录)
黑马程序猿的python学习视频：https://www.bilibili.com/video/BV1qW4y1a7fU/
===============================================================
目录
一 、print
1. end''
2. \t对齐
二、字面量
1. 字面量的含义
2. 常见的字面量类型
3. 如何基于print语句完成各类字面量的输出
三、 注释的分类
1. 单行注释
2. 多行注释
3. 注释的作用是什么
4. 单行注释如何定义
5. 多行注释如何定义
四、 变量
1. 什么是变量
2. 变量的格式是
3. 变量的特征
4. print语句如何输出多份内容
5. python中如何做运算
五、 数据分类
1. 数据类型的分类
2. type()查看数据类型
3. 变量有类型吗
六、 数据类型转换
1. 任何类型都可以转换成字符串，对不对
2. 字符串可以随意转换成数字，对不对
3. 浮点数转成整数会丢失什么
七、 标识符
八、 运算符
九、 字符串扩展
1. 字符串的三种定义方式
2. 字符串的拼接
3. 常用的字符串格式化
4. 精度控制语法
5. 如果m比数字本身宽度小，会发生什么
6. .n会对小数部分做精度限制，同时？
7. f{}的拼接语法
8. input语句的基本使用
9. 查看索引位置index
10.字符串的替换 replace
10. 分割字符串split
11. 字符串去除前后空格strip()
12. 字符串去除首尾指定字符串strip(参数 )
13. 统计字符串中某个字符串出现的次数count
14. 统计字符串的长度len
15. 切片
十、布尔类型
十一、 比较运算符
十二、 if语句
十三、 循环
1. while循环
a. 练习题：求1-100的和
b. 练习题九九乘法表
2. for循环
3. for循环的九九乘法表
4. range
5. continue和break
十四、 函数
1. 函数定义
2. 有返回值的函数
3. 函数的None
4. 函数的多返回值
5. 传参不限个数*args
6. 传参不限个数**kwargs
十五、 数据容器-列表
1. 基础概念
2. 用法总结
3. index(元素)查看元素索引
4. 插入元素insert
5. 追加一个元素append
6. 追加一批元素extend
7. 删除列表元素 ：del 列表[下标]
8. 删除列表元素：列表.pop（下标）
9. 删除列表元素：remove
10. 删除列表的所有元素clear()
11. 统计某个元素 在列表中的数量count(元素)
12. 统计列表中全部元素的数量len(列表)
十六、 数据容器-元组
1. 元组定义
2. 元组操作
3. 元组的特点
4. 切片
十七、 数据容器-集合
1. 集合的概念
2. 定义集合
3. 添加新元素 集合.add(元素)
4. 移除元素 集合.remove(元素)
5. 随机取出一个元素pop
6. 清空集合clear
7. 取出2个集合的差集difference
8. 消除2个集合的差集difference_update
9. 2个集合合并为1个union
10. 统计集合元素数量len
十八、 数据容器-字典
1. 字典的定义
2. 定义重复key的字典
3. 取值
4. 新增元素/更新元素
5. 删除元素pop
6. 清空字典clear
7. 获取全部key 字典.keys()
8. 遍历字典
9. 统计字典内的元素数量 len()
十九、 数据容器分类
二十、 数据容器排序
二十一、 lambda
==================================================================
一 、print
1. end''
| 换行 |
不换行 |
| print("hello") print("world") |
print("hello",end='') print("world",end='') |
| hello world 进程已结束,退出代码0 |
helloworld 进程已结束,退出代码0 |
2. \t对齐
| 不对齐 |
对齐 |
| print("world world") print("worl word") |
print("world\tworld") print("worl\tword") |
| world world worl word 进程已结束,退出代码0 |
world world worl word 进程已结束,退出代码0 |
|
|
|
二、字面量
1. 字面量的含义
代码中，被写在代码中的固定的值，称之为字面量。
2. 常见的字面量类型
我们目前了解：整数、浮点数、字符串这三类即可
3. 如何基于print语句完成各类字面量的输出
print(字面量)，如：
print(10)，输出10
print(13.14),输出13.14
print("hello");输出 hello
注释：在程序代码中对程序代码进行解释说明的文字。
作用：注释不是程序，不能呗执行。只是对程序代码进行解释说明。让别人可以看懂程序代码的作用，能够大大增加程序的可读性
三、 注释的分类
1. 单行注释
2. 多行注释
“”“
”“”
一对三个双引号引起来的注释
一般写在文件的开头
3. 注释的作用是什么
注释是代码中的解释型语句，用来对代码内容进行注释
注释不是代码，不会被程序执行
4. 单行注释如何定义
通过#定义，在#号的右侧的所有内容均作为注释
建议在#号和注释内容之间，间隔一个空格
单行注释一般用于对一行或小部分代码进行解释
5. 多行注释如何定义
通过一对三个引号来定义("""注释内容""")，引号内容均是注释，可以换行
多行注释一般对：python文件，类和方法进行解释
四、 变量
1. 什么是变量
在程序运行时，能储存计算结果或能表示值的抽象概念。
简单的说，变量就是在程序运行时，记录数据用的
2. 变量的格式是
变量名 = 变量值
3. 变量的特征
变量的值可以改变
4. print语句如何输出多份内容
print(内容1，内容2,..........，内容n)
5. python中如何做运算
加减乘除：+ - * /
五、 数据分类
1. 数据类型的分类
在学习字面量的时候，我们了解到：数据是有类型的、
目前在入门阶段，我们主要接触如下三类数据类型：
string int float
2. type()查看数据类型
3. 变量有类型吗
变量没有类型。但是存储的数据有类型。
我们通过type(变量)可以输出类型，这是查看变量的类型还是数据的类型？
查看的是：变量存储的是数据的类型。因为，变量无类型，但是它存储的数据有。
六、 数据类型转换
print("int转string", type(str(123)),str(123))
print("float转string", type(str(123.123)),str(123.123))
print("int转float", type(float(123)),float(123))
print("float转int", type(int(123.12)),int(123.12))
1. 任何类型都可以转换成字符串，对不对
正确
2. 字符串可以随意转换成数字，对不对
不对。字符串内必须只有数字才可以
3. 浮点数转成整数会丢失什么
丢失精度，也就是小数部分
七、 标识符
八、 运算符
九、 字符串扩展
1. 字符串的三种定义方式
转义
| name = "'张三" print(name) name = '"张三' print(name) name = "\"张三\"" print(name) name = "\'张三\'" print(name) '张三 "张三 "张三" '张三' |
2. 字符串的拼接
| name="李四" message="我的名字是%s"%name print(message) xinzi=1000 message="我的名字是%s,薪资是%s"%(name,xinzi) print(message) |
3. 常用的字符串格式化
字符串 %s
整数 %d
浮点数 %f
4. 精度控制语法
m.n的形式控制，如%5d,%5.2f,%.2f
m和.n均可省略
5. 如果m比数字本身宽度小，会发生什么
m不生效
6. .n会对小数部分做精度限制，同时？
会对小数部分做四舍五入
7. f{}的拼接语法
| name="张三" age=18 xinzi=3000.23 print(f"我的名字是{name}，年龄是：{age}，薪资是：{xinzi}") 输出结果是： 我的名字是张三，年龄是：18，薪资是：3000.23 |
8. input语句的基本使用
| name = input("你的名字是：") print(name) |
| 输出：zhnagsan |
9. 查看索引位置index
| value="abc def"; print(value.index("d")) |
| 4 |
10.字符串的替换 replace
| value="abc def abc"; new_value = value.replace("a","g") print(new_value) |
| gbc def gbc |
10. 分割字符串split
| value="abc def abc"; new_value = value.split(" ") print(new_value) |
| ['abc', 'def', 'abc'] |
11. 字符串去除前后空格strip()
| value=" abc def abc "; new_value = value.strip() print(new_value) |
| abc def abc |
12. 字符串去除首尾指定字符串strip(参数 )
| value="abc def abc"; print(value.strip("ab")) |
value="abc def cab"; print(value.strip("ab")) |
| c def abc |
c def c |
13. 统计字符串中某个字符串出现的次数count
| value="abc def cab"; print(value.count("ab")) |
| 2 |
14. 统计字符串的长度len
| value="abc def cab"; print(len(value)) |
| 11 |
15. 切片
| value="0123456"; print(value[1:3]) |
value="0123456"; print(value[::2]) |
| 12 |
0246 |
十、布尔类型
布尔类型的值 是True 和 False
十一、 比较运算符
十二、 if语句
if
| if(3>2): print("3>2") |
| 3>2 |
if else
| if(3<2): print("11111") else: print("22222") |
| 222222 |
if elif else
| num=10 if(num==1): print("num==1") elif(num==10): print("num==10") else: print("num==7") |
| num==10 |
十三、 循环
1. while循环
a. 练习题：求1-100的和
| num=1 sum=0 while num<=100: sum+=num num+=1 print(sum) |
| 5050 |
b. 练习题九九乘法表
| i=1; while i<10: j = 1; while j<=i: print(f"{j}*{i}={i*j}\t",end='') j+=1; i += 1; print() |
| 1*1=1 1*2=2 2*2=4 1*3=3 2*3=6 3*3=9 1*4=4 2*4=8 3*4=12 4*4=16 1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81 |
2. for循环
| data="hello world"; for item in data: print(item) |
| h e l l o w o r l d |
3. for循环的九九乘法表
end='' 不换行
\t 对齐
print()换行
| for i in range(1,10): for j in range(1,i+1): print(f"{j}*{i}={j*i}\t",end='') print() |
| 1*1=1 1*2=2 2*2=4 1*3=3 2*3=6 3*3=9 1*4=4 2*4=8 3*4=12 4*4=16 1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81 |
4. range
| range(num) |
range(num，num) |
range(num，num,step) |
| data = range(5) for item in data: print(item) |
data = range(5,8) for item in data: print(item) |
data = range(5,10,2) for item in data: print(item) |
| 0 1 2 3 4 |
5 6 7 |
5 7 9 |
5. continue和break
continue：直接进行下次循环
break：结束循环
十四、 函数
1. 函数定义
2. 有返回值的函数
| def add(a,b): return a+b; result = add(3,30); print(result) |
| 33 |
3. 函数的None
4. 函数的多返回值
| def test(): return 1,2,3 x,y,z=test() print(f"{x},{y},{z}") |
| 1,2,3 |
5. 传参不限个数*args
| def test(*args): print(args) test("1", "2", "3") |
| ('1', '2', '3') |
6. 传参不限个数**kwargs
| def test(**kwargs): print(kwargs) test(name="12", age="22", sex="22") |
| {'name': '12', 'age': '22', 'sex': '22'} |
十五、 数据容器-列表
1. 基础概念
列表的正向索引取值方法
列表的反向索引取值方法
2. 用法总结
3. index(元素)查看元素索引
| 元素存在 |
元素不存在 |
| mylist=[1,2,3] print(mylist.index(1)) |
mylist=[1,2,3] print(mylist.index(5)) |
| 0 |
ValueError: 5 is not in list |
4. 插入元素insert
列表.insert（下标,元素），在指定的位置插入指定的值
| mylist=[1,2,3] mylist.insert(1,"啦啦") print(f"最新的数据时：{mylist}") |
| 最新的数据时：[1, '啦啦', 2, 3] |
5. 追加一个元素append
列表append(元素)，将指定的元素，追加到列表的尾部
| mylist=[1,2,3] mylist.append("lala") print(f"最新的数据是：{mylist}") |
| 最新的数据是：[1, 2, 3, 'lala'] |
6. 追加一批元素extend
列表.extend(其他数据容器)，将其他的数据容器的内容取出。依次追加到列表的尾部
| mylist=[1,2,3] mylist.extend([5,6,7]) print(f"最新的数据是：{mylist}") |
| 最新的数据是：[1, 2, 3, 5, 6, 7] |
7. 删除列表元素 ：del 列表[下标]
通过下标删除元素
| mylist=[1,2,3] del mylist[1] print(f"最新的数据是：{mylist}") |
| 最新的数据是：[1, 3] |
8. 删除列表元素：列表.pop（下标）
通过下标删除元素
| mylist=[1,2,3] del_data=mylist.pop(1) print(f"最新的数据是：{mylist},取出的值是{del_data}") |
| 最新的数据是：[1, 3],取出的值是2 |
9. 删除列表元素：remove
只会删除第一个匹配的元素
通过元素删除列表元素
| mylist=[1,2,3,1] mylist.remove(1) print(f"最新的数据是：{mylist}") |
| 最新的数据是：[2, 3, 1] |
10. 删除列表的所有元素clear()
| mylist=[1,2,3,1] mylist.clear() print(f"最新的数据是：{mylist}") |
| 最新的数据是：[] |
11. 统计某个元素 在列表中的数量count(元素)
| mylist=[1,2,3,1] count=mylist.count(1) print(count) |
| 2 |
12. 统计列表中全部元素的数量len(列表)
| mylist=[1,2,3,1] count=len(mylist) print(count) |
| 4 |
十六、 数据容器-元组
1. 元组定义
2. 元组操作
3. 元组的特点
4. 切片
十七、 数据容器-集合
1. 集合的概念
集合是无序的，所以集合不支持：下标索引访问
但是集合和列表一样，是允许修改的
2. 定义集合
| my_set={"张三","李四","王五","张三"} print(my_set) |
| {'张三', '李四', '王五'} |
3. 添加新元素 集合.add(元素)
| my_set={"张三","李四","王五","张三"} my_set.add("1") print(my_set) |
| {'1', '李四', '张三', '王五'} |
4. 移除元素 集合.remove(元素)
| my_set={"张三","李四","王五","张三"} my_set.remove("李四") print(my_set) |
| {'张三', '王五'} |
5. 随机取出一个元素pop
| my_set={"张三","李四","王五","张三"} my_set.pop() print(my_set) |
| {'张三', '李四'} pop随机去掉一个元素 |
6. 清空集合clear
| my_set={"张三","李四","王五","张三"} my_set.clear() print(my_set) |
| set() |
7. 取出2个集合的差集difference
集合1.difference(集合2)：取出集合1有而集合2没有的。原来的2个集合不变
| set1={1,2,3} set2={1,3,5} set3=set1.difference(set2) print(set3) |
| {2} |
8. 消除2个集合的差集difference_update
集合1.difference_update(集合2)
对比集合1和集合2，在集合1中删除和集合2相同的元素
结果：集合1被修改 集合2不变
| set1={1,2,3} set2={1,3,5} set1.difference_update(set2) print(set1) |
| {2} |
9. 2个集合合并为1个union
集合1.union(集合2)
将集合1和集合2组合成新的集合
结果：得到新集合 集合1和集合2不变
| set1={1,2,3} set2={1,3,5} set3 = set1.union(set2) print(set3) |
| {1, 2, 3, 5} |
10. 统计集合元素数量len
| set1={1,2,3} print(len(set1)) |
| 3 |
十八、 数据容器-字典
1. 字典的定义
| my_dict1={"1":"张三","2":"李四","3":"王五"} my_dict2={} my_dict3=dict() print(f"my_dict1的内容是：{my_dict1}，类型：{type(my_dict1)}") print(f"my_dict2的内容是：{my_dict2}，类型：{type(my_dict2)}") print(f"my_dict3的内容是：{my_dict3}，类型：{type(my_dict3)}") |
| my_dict1的内容是：{'1': '张三', '2': '李四', '3': '王五'}，类型： my_dict2的内容是：{}，类型： my_dict3的内容是：{}，类型： |
2. 定义重复key的字典
| my_dict1={"1":"张三","1":"李四","3":"王五"} print(f"my_dict1的内容是：{my_dict1}，类型：{type(my_dict1)}") |
| my_dict1的内容是：{'1': '李四', '3': '王五'}，类型： 重复的key ：后边的数据会把前边重复的数据给覆盖掉 |
3. 取值
| my_dict1={"1":"张三","2":"李四","3":"王五"} print(my_dict1["2"]) |
| 李四 |
4. 新增元素/更新元素
字典[key]=value
如果key存在，就是更新
如果key不存在 就是新增
5. 删除元素pop
| my_dict1={"1":"张三","2":"李四","3":"王五"} score = my_dict1.pop("2") print(my_dict1) print(score) |
| {'1': '张三', '3': '王五'} 李四 |
6. 清空字典clear
| my_dict1={"1":"张三","2":"李四","3":"王五"} my_dict1.clear() print(my_dict1) |
| {} |
7. 获取全部key 字典.keys()
语法：字典.keys(),结果：得到字典中的全部key
| my_dict1={"1":"张三","2":"李四","3":"王五"} keys = my_dict1.keys() print(keys) |
| dict_keys(['1', '2', '3']) |
8. 遍历字典
| 方法1：获取到全部key 循环key实现遍历 |
方法2：直接对字典for循环，循环的是key，所以能直接循环字典实现遍历 |
| my_dict1={"1":"张三","2":"李四","3":"王五"} keys = my_dict1.keys() for element in keys: print(f"key:{element},value:{my_dict1[element]}") |
my_dict1={"1":"张三","2":"李四","3":"王五"} for key in my_dict1: print(f"key:{key},value:{my_dict1[key]}") |
| key:1,value:张三 key:2,value:李四 key:3,value:王五 |
key:1,value:张三 key:2,value:李四 key:3,value:王五 |
9. 统计字典内的元素数量 len()
| my_dict1={"1":"张三","2":"李四","3":"王五"} print(len(my_dict1)) |
| 3 |
十九、 数据容器分类
二十、 数据容器排序
sorted(容器) 正序
sort(容器,reverse=True) 倒序
| data=[3,1,2,4,5] print(sorted(data)) print(sorted(data,reverse=True)) |
| [1, 2, 3, 4, 5] [5, 4, 3, 2, 1] |
二十一、 lambda
