【Python学习笔记】超详细Python快速入门教程（上）

---

001 print输出函数

# 可以输出数字、文字、列表等
print(123)
print("文字")
print([1, 2, 3])

# 还可以输出运算表达式
print(1 + 1)

# 将数据输出到文件中
outStream = open(r"E:\Software\JetBrainsIDEA\PythonIDEA\Projects\CXSJS\Python\Python学习\01输出函数\print.txt", "a+")
print("hello world", file=outStream)
outStream.close()

# 不进行换行输出(输出在一行中，用空格隔开)
print("Java","C++","Python")

# 自定义print结尾符号(不写默认为\n换行符)
print("hello world",end="  自定义结束符号")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

002 转义字符

# 换行符 \n
print("hello\nworld")

# 水平制表符 \t
print("hello\tworld")

# 回车 \r
print("hello\rworld")

# 退格 \b
print("hello\bworld")

# 反斜杠 \\
print("\\")

# 单引号 \'
print("\'")

#原字符，即不希望字符串中的转义字符起作用，就使用原字符，就是在字符串之前加上 r 或 R
print(r"\\")

# 注意事项，最后一个字符不能是反斜杠
# print("hello\")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

003 二进制与字符编码

print(chr(0b100111001011000))
print(ord("乘"))
1
2

004 变量的定义与使用

name = "玛卡巴卡"
print("标识",id(name))
print("类型",type(name))
print("值",name)

# 变量多次赋值后，变量名会指向新的内存空间
name = "唐伯利伯"
print("新的值",name)
1
2
3
4
5
6
7
8

005 整数类型

# 整数类型
# 英文为integer,.简写为int,可以表示正数、负数和零
# 整数的不同进制表示方式
# 十进制 默认的进制
# 二进制 以0b开头
# 八进制 以0o开头
# 十六进制 以0x开头

# 可以表示，正数，负数，0
n1 = 90
n2 = -76
n3 = 0
print(n1, type(n1))
print(n2, type(n2))
print(n3, type(n3))

# 整数可以表示为二进制，十进制，八进制，十六进制
print('十进制', 118)
print('二进制', 0b10101111)  # 二进制以0b开头
print('八进制', 0o176)  # 八进制以0o开头
print('十六进', 0x1EAF)  # 十六进制以0x开头
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

006 浮点类型

# 浮点类型
a = 3.14159
print(a,type(a))
# 浮点数整数部分和小数部分组成
# 浮点数存储不精确性
# 使用浮点数进行计算时，可能会出现小数位数不确定的情况
print(1.1 + 2.2)  # 3.3000000000000003
print(1.1 + 2.1)  # 3.2

# 解决方案
# 导入模块decimal
from decimal import Decimal

print(Decimal('1.1') + Decimal('2.2'))  # 3.3
1
2
3
4
5
6
7
8
9
10
11
12
13
14

007 布尔类型

# 布尔类型
# 用来表示真或假的值
# True表示真，False表示假
# 布尔值可以转化为整数
# True→1
# False→0
print(True + 1)  # 2
print(False + 1) # 1

f1 = True
f2 = False
print(f1, type(f1))
print(f2, type(f2))
1
2
3
4
5
6
7
8
9
10
11
12
13

008 字符串类型

# 字符串类型
# 字符串又被称为不可变的字符序列
# 可以使用单引号' 双引号" 三引号''' 来定义
# 单引号和双引号定义的字符串必须在一行
# 三引号定义的字符串可以分布在连续的多行
str1 = '人生苦短，我用Python'
str2 = "人生苦短，我用Python"
str3 = "人生苦短，我用Python"
str4 = '''人生苦短,
     我用Python'''
print(str1, type(str1))
print(str2, type(str2))
print(str3, type(str3))
print(str4, type(str4))
1
2
3
4
5
6
7
8
9
10
11
12
13
14

009 数据类型的转换

name = "张三"
age = 20
# name与age的数据类型不相同
print(type(name), type(age))

# 不同类型之间不能直接用 + 连接符 (TypeError: can only concatenate str (not "int") to str)
# print('我叫' + name + ',今年' + age + '岁')

# 解决方案：类型转换
print('我叫' + name + ',今年' + str(age) + '岁')  # 将int类型通过str(0函数转成了str类型

print("------ str()将其它类型转成str类型 ------")
a = 10
b = 198.8
c = False
print(type(a), type(b), type(c))
print(str(a), str(b), str(c), type(str(a)), type(str(b)), type(str(c)))

print("---- int()将其它的类型转int类型 -----")
s1 = '128'
f1 = 98.7
s2 = '76.77'
ff = True
s3 = 'hello'
print(type(s1), type(f1), type(s2), type(ff), type(s3))
print(int(s1), type(int(s1)))  # 将str转成int类型，字符串为数字串
print(int(f1), type(int(f1)))  # f1oat转成int类型，截取整数部分，舍掉小数部分
# print(int(s2),type(int(s2)) # 将str转成int类型，报错，因为字符串为小数串
print(int(ff), type(int(ff)))
# print(int(s3),type(int(s3))#将str转成int类型时，字符串必须为数字串（整数），非数字串是不允许转换

print("---------- f1oat()函数，将其它数据类型转成f1oat类型 -----------")
s1 = '128.98'
s2 = '76'
ff = True
s3 = 'hello'
i = 98
print(type(s1), type(s2), type(ff), type(s3), type(i))
print(float(s1), type(float(s1)))
print(float(s2), type(float(s2)))
print(float(ff), type(float(ff)))
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

010 注释

# 注释
# 在代码中对代码的功能进行解释说明的标注性文字，可以提高代码的可读性
# 注释的内容会被Python解释器忽略
# 通常包括三种类型的注释:
# 1.单行注释→以”#”开头，直到换行结束
# 2.多行注释→并没有单独的多行注释标记，将一对三引号之间的代码称为多行注释
# 3.中文编码声明注释→在文件开头加上中文声明注释，用以指定源码文件的编码格式
# coding.gbk

'''
我是多行注释
'''

str = '''我不是多行注释,
我是多行字符串'''
print(str)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

011 input函数

# 输入函数input
present = input('大圣想要什么礼物呢？')
print(present, type(present))

# 从键盘录入两个整数，计算两个整数的和
a = int(input('请输入一个加数：'))
# a=int (a)
# 将转换之后的结果存储到a中
b = int(input('请输入另-个加数：'))
# b=int (b)
print(type(a), type(b))
print(a + b)
1
2
3
4
5
6
7
8
9
10
11
12

012 算术运算符

print(1 + 1)  # 加法运算
print(1 - 1)  # 减法运算
print(2 * 4)  # 乘法运算
print(1 / 2)  # 除法运算
print(11 / 2)  # 除法运算
print(11 // 2)  # 整除运算
print(11 % 2)  # 取余运算
print(2 ** 2)  # 表示的是2的2次方
print(2 ** 3)  # 表示的是2的3次方2*2*2

print(9 // 4)  # 2
print(-9 // -4)  # 2
print(9 // -4)  # -3
print(-9 // 4)  # -3   一正一负的整数公式，向下取整
print(9 % -4)  # -3    公式余数=被除数-除数*商 9-(-4)*(-3)9-12-->-3
print(-9 % 4)  # 3     -9-4*(-3)-9+12 --> 3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

013 赋值运算符

# 赋值运算符，运算顺序从右到左
i = 3 + 4
print(i)
a = b = c = 20
# 链式赋值
print(a, id(a))
print(b, id(b))
print(c, id(c))
print('------------- 支持参数赋值 -------------')
a = 20
a += 30  # 相当于a=a+30
print(a)
a -= 10  # 相当于a=a-10
print(a)
a *= 2  # 相当于a=a*2
print(a)
a /= 3
print(a)
a //= 2
print(a)
a %= 3
print(a)
print('------------- 解包赋值 -------------')
a, b, c = 20, 30, 40
print(a, b, c)  # a,b=20,30,40报错，因为左右变量的个数和值的个数不对应
print('---------- 交换两个变量的值 -----------')
a, b = 10, 20
print('交换之前：', a, b)  # 交换
a, b = b, a
print('交换之后：', a, b)
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

014 比较运算符

# 比较运算符，比较运算符的结果为b0o1类型
a, b = 10, 20
print('a>b吗？', a > b)  # False
print('a, a < b)  # True
print('a<=b吗？', a <= b)  # True
print('a>=b吗？', a >= b)  # False
print('a==b吗？', a == b)  # False
print('a!=b吗？', a != b)  # Irue

'''
一个=称为赋值运算符，==称为比较运算符
一个变量由三部分组成，标识，类型，值
== 比较的是值还是标识呢？比较的是值
比较对象的标识使用 is
'''

a = 10
b = 10
print(a == b)  # True说明，a与b的value相等
print(a is b)  # True说明，a与b的id标识，相等

# 以下代码没学过，后面会给大家讲解
list1 = [11, 22, 33, 44]
list2 = [11, 22, 33, 44]
print(list1 == list2)  # value-->True
print(list1 is list2)  # id-->False
print(id(list1))
print(id(list2))
print(a is not b)  # False a的id与b的id是不相等的
print(list1 is not list2)  # True
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

015 布尔运算符

# 布尔运算符
a, b = 1, 2
print("--- and 并且 ---")
print(a == 1 and b == 2)  # True True and True-->True
print(a == 1 and b < 2)  # False True and False -->False
print(a != 1 and b == 2)  # False False and True-->False
print(a != 1 and b != 2)  # False False and False -->False

print("--- or 或者 ---")
print(a == 1 or b == 2)  # True or True-->True
print(a == 1 or b < 2)  # True or False-->True
print(a != 1 or b == 2)  # False or True -->True
print(a != 1 or b != 2)  # False or False -->False

print("--- not 对bool类型取反 ---")
f = True
f2 = False
print(not f)
print(not f2)

print("--- in 与 not in ---")
s = 'helloworld'
print('w' in s)  # True
print('k' in s)  # False
print('w' not in s)  # False
print('k' not in s)  # True
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

016 位运算符

print(4 & 8)  # 按位与&，同为1时结果为]
print(4 | 8)  # 按位或，同为0时结果为0
print(4 << 1)  # 向左移动1位（移动一个位置）相当于乘以2
print(4 << 2)  # 向左移动2位（移动2个位置）
print(4 >> 1)  # 向右移动1位，相当于除以2
print(4 >> 2)  # 向右移动2位，相当于除以4
1
2
3
4
5
6

017 对象的布尔值

# Python一切皆对象，所有对象都有一个布尔值
# 获取对象的布尔值
# 使用内置函数bool()
# 以下对象的布尔值为False
# False
# 数值0
# None
# 空字符串、空列表、空元组、空字典、空集合

# 测试对象的布尔值
print(bool(False))  # False
print(bool(0))  # False
print(bool(0.0))  # False
print(bool(None))  # False
print(bool(''))  # False
print(bool(""))  # False
print(bool([]))  # 空列表
print(bool(list()))  # 空列表
print(bool())  # 空元组
print(bool(tuple()))  # 空元组
print(bool({}))  # 空字典
print(bool(dict(())))  # 空字典
print(bool(set()))  # 空集合
print('----- 以上对象的布尔值为False -----')
print('----- 其它对象的布尔值均为True -----')
print(bool(18))
print(bool(True))
print(bool('helloworld'))
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

018 选择结构

a = int(input("请输入一个数字:"))
if a < 0:
    print("a是负数")
elif a == 0:
    print("a为0")
else:
    print("a是正数")
1
2
3
4
5
6
7

019 条件表达式

# 条件表达式是if ... else的简写

# 从键盘录入两个整数，比较两个整数的大小，
numa = int(input('请输入第一个整数'))
numb = int(input('请输入第二个整数'))
# 比较大小
print(str(numa) + '大于等于' + str(numb) if numa >= numb else str(numa) + '小于' + str(numb))
1
2
3
4
5
6
7

020 pass语句

# pass语句
# 语句什么都不做，只是一个占位符，用在语法上需要语句的地方
# 什么时候使用：
# 先搭建语法结构，还没想好代码怎么写的时候
# 哪些语句一起使用
# if语句的条件执行体
# for-in语句的循环体
# 定义函数时的函数体

a = 10
if a != 10:
    # pass : 暂时没想到if里要怎么写，就先用pass进行占位，防止报错
    pass

for i in [1,2,3]:
    pass

def add():
    pass
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

021 range函数

# range()的三种创建方式
# 第一种创建方式，只有一个参数（小括号中只给了一个数）
r = range(10)
print(r)  # range (0,10)
print(list(r))  # 用于查看range对象中的整数序列->1ist是列表的意思

# 第二种创建方式，给了两个参数（小括号中给了两个数）’
r = range(1, 10)
# 指定了起始值和结束值，从1开始，到10结束（不包含10），默认步长为1
print(list(r))  # [1,2,3,4,5,6,7,8,9]

# 第三种创建方式，给了三个参数（小括号中给了三个数） 起始值，结束值，步长
r = range(1, 10, 2)
print(list(r))  # [1,3,5,7,9]
# 判断指定的整数在序列中是否存在in,not in'’,
print(10 in r)  # False,10不在当前的r这个整数序列中
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

022 循环结构

# while循环
a = 0
s = 0
# 条件判断
while a < 5:
    # 条件执行体（循环体）
    s += a
    # 改变变量
    a += 1
print('和为', s)

# for-in循环
for item in 'Python':  # 第一次取出来的是P,将P赋值值item,将item的值输出
    print(item)

# range()产生一个整数序列 -> 也是一个可迭代对象
for i in range(10):
    print(i)

# 如果在循环体中不需要使用到自定义变量，可将自定义变量写为"_"
for _ in range(5):
    print('人生苦短，我用Python')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

023 流程控制语句

# break流程控制语句 直接跳出循环
# 从键盘录入密码，最多录入3次，如果正确就结束循环
for item in range(3):
    pwd = input('请输入密码：')
    if pwd == '666':
        print('密码正确')
        break
    else:
        print('密码不正确')

# continue流程控制语句 直接跳到循环最后一行，继续往下执行
for item in range(1, 51):
    if item % 5 != 0:
        # 如果输出不是5的倍数，那就跳过，继续往后遍历
        continue
    print(item)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

024 for-else和while-else

# for else
for item in range(3):
    pwd = input('请输入密码：')
    if pwd == '666':
        print('密码正确')
        break
    else:
        print('密码不正确')
else:
    print("对不起，三次输错密码，程序退出")

# while else
i = 0
while i < 3:
    pwd = input('请输入密码：')
    if pwd == '666':
        print('密码正确')
        break
    else:
        print('密码不正确')
    i += 1
else:
    print("对不起，三次输错密码，程序退出")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

025 list列表

# 列表特点
# 1.列表元素按顺序有序排序
# 2.索引映射唯一个数据
# 3.列表可以存储重复数据
# 4.任意数据类型混存
# 5.根据需要动态分配回收内存

# 列表的创建方式
# 1.使用中括号
# 2.调用内置函数list()
# 创建列表的第一种方式，使用[]
lst = ['hello', 'world', 98]
print(lst)

# 创建列表的第二种方式，使用内置函数list()
lst2 = list(['hello', 'wor1d', 98])
print(lst2)

# 列表的查询操作
lst = ['hello', 'world', 98, 'hello']
print(lst.index('hello'))  # 如果列表中有相同元素只返回列表中相同元的第一个元素的索引
print(lst.index('hello', 1, 4))  # 指定在索引[1,4)之间查找'hello'

lst = ['he11o', 'wor1d', 98, 'he11o', 'wor1d', 234]
# 获取索引为2的元素
print(lst[2])
# 获取索引为-3的元素
print(lst[-3])

# 切片语法，查询多个值 列表名[start:stop:step]
lst = [10, 20, 30, 40, 50, 60, 70, 80]
# start=1,stop=6,step=1
print(lst[1:6:1])  # [20, 30, 40, 50, 60]
print('原列表id:', id(lst))  # 原列表id: 2635065003328
lst2 = lst[1:6:1]
print('切的片段id:', id(lst2))  # 切的片段id: 2635064674752
# start=1,stop=6,step=2
print(lst[1:6:2])  # [20, 40, 60]
# start=1,stop=6,step不写，默认step为1
print(lst[1:6:])  # [20, 30, 40, 50, 60]
# start不写,stop=6,step=2，默认start从0开始
print(lst[:6:2])  # [10, 30, 50]
# start=1,stop不写,step=2，不写stop，则默认一直取到数组的端点
print(lst[1::2])  # [20, 40, 60, 80]
# 步长为负数的情况
print("步长为负数的情况")
print("原列表：", lst)  # 原列表： [10, 20, 30, 40, 50, 60, 70, 80]
print("负数步长截取的列表:", lst[::-1])  # 负数步长截取的列表: [80, 70, 60, 50, 40, 30, 20, 10]
# start=7,stop省略step=-1
print(lst[7::-1])  # [80, 70, 60, 50, 40, 30, 20, 10]
# start=6,stop=0,step=-2
print(lst[6:0:-2])  # [70, 50, 30]

# 列表的 in 和 not in
lst = [10, 20, 'python']
print('python' in lst)  # True
print(10 not in lst)  # False

# 列表的遍历
for item in lst:
    print(item)
'''
10
20
python
'''

# 往列表中添加元素，默认在末尾追加
lst = [10, 20, 30]
print('添加元素之前', lst, id(lst))  # 添加元素之前 [10, 20, 30] 2635065003328
lst.append(100)
print('添加元素之后', lst, id(lst))  # 添加元素之后 [10, 20, 30, 100] 2635065003328

# 向列表的末尾一次性添加多个元素
lst2 = [1, 2, 3]
lst.extend(lst2)
print(lst)  # [10, 20, 30, 100, 1, 2, 3]
# 在任意位置上添加一个元素
lst.insert(1, 90)
print(lst)  # [10, 90, 20, 30, 100, 1, 2, 3]

# 在任意的位置上添加N多个元素
lst3 = [True, False, 'hello']
lst[1:] = lst3
print(lst)  # [10, True, False, 'hello']

# 列表元素的删除操作
lst = [10, 20, 30, 40, 50, 60, 30]
lst.remove(30)  # 从列表中移除一个元素，如果有重复元素只移第一个元素
print(lst)  # [10, 20, 40, 50, 60, 30]
# lst.remove(100) # ValueError:list.remove(x):x not in list
# pop()根据索引移除元素
lst.pop(1)  # 将索引为1处的元素移除
print(lst)  # [10, 40, 50, 60, 30]

lst.pop()  # 如果不指定参数（索引），将删除列表中的最后一个元素
print(lst)  # [10, 40, 50, 60]

print('----- 切片操作  删除至少一个元素，将产生一个新的列表对象 ----')
new_list = lst[1:3]
print('原列表', lst)  # 原列表 [10, 40, 50, 60]
print('切片后的列表', new_list)  # 切片后的列表 [40, 50]

# 不产生新的列表对象，而是删除原列表中的内容
lst[1:3] = []
print(lst)  # [10, 60]

# clear() 清除列表中所有元素
lst.clear()
print(lst)  # []

# 从内存中 删除列表对象
del lst
# print(lst) # NameError: name 'lst' is not defined

# 修改列表元素
lst = [10, 20, 30, 40]
# 一次修改一个值
lst[2] = 100
print(lst)  # [10, 20, 100, 40]
# 切片 一次修改多个值
lst[1:3] = [300, 400, 500, 600]
print(lst)  # [10, 300, 400, 500, 600, 40]

# 列表的排序操作
lst = [20, 40, 10, 98, 54]
print('排序前的列表', lst, id(lst))  # 排序前的列表 [20, 40, 10, 98, 54] 2880607226688
# 开始排序，调用列表对象的s0rt方法，升序排序
lst.sort()
print('排序后的列表', lst, id(lst))  # 排序后的列表 [10, 20, 40, 54, 98] 2880607226688

# 通过指定关键字参数，将列表中的元素进行降序排序
lst.sort(reverse=True)
# reverse表示:是否反转 在排序中，默认是升序排序，所以 reverse=True表示降序排序，reverse=False就是升序排序
print(lst)  # [98, 54, 40, 20, 10]
lst.sort(reverse=False)
print(lst)  # [10, 20, 40, 54, 98]

print('--------- 使用内置函数sorted()对列表进行排序，将产生一个新的列表对象 --------------')
lst = [20, 40, 10, 98, 54]
print('原列表', lst)  # 原列表 [20, 40, 10, 98, 54]
# 开始排序
new_list = sorted(lst)
print(lst, id(lst))  # [20, 40, 10, 98, 54] 2142558816640
print(new_list, id(new_list))  # [10, 20, 40, 54, 98] 2142558816896

# 列表生成式
lst = [i * i for i in range(10)]
print(lst)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

lst = [i * 2 for i in range(1, 6)]
print(lst)  # [2, 4, 6, 8, 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
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

026 dict字典

# 字典是：
# Python内置的数据结构之一，与列表一样是一个可变序列
# 以键值对的方式存储数据，字典是一个无序的序列

# 字典的特点
# 字典中的所有元素都是一个key-value对，key不允许重复，value可以重复
# 字典中的元素是无序的
# 字典中的key必须是不可变对象
# 字典也可以根据需要动态地伸缩
# 字典会浪费较大的内存，是一种使用空间换时间的数据结构

# 字典的创建方式，
# 使用{}创建字典’
scores = {'张三': 100, '李四': 98, '王五': 45}
print(scores)  # {'张三': 100, '李四': 98, '王五': 45}
print(type(scores))  # 

# 第二种创建方式 dict()
student = dict(name='jack', age=20)
print(student)  # {'name': 'jack', 'age': 20}

# 空字典
d = {}
print(d)  # {}

# 字典中元素的获取
# 获取字典的元素
scores = {'张三': 100, '李四': 98, '王五': 45}
# 第一种方式，使用[]
print(scores['张三'])  # 100
# print(scores['陈六，]) # KeyError:'陈六'
# 第二种方式，使用get()方法’，
print(scores.get('张三'))  # 100
print(scores.get('陈六'))  # None
print(scores.get('麻七', 99))  # 99 是在查找'麻七'所对的value不存在时，提供的一个默认值

# key的判断
scores = {'张三': 100, '李四': 98, '王五': 45}
print('张三' in scores)  # True
print('张三' not in scores)  # False

# 删除指定的键值对
del scores['张三']  # 删除指定的key-value对
print(scores)  # {'李四': 98, '王五': 45}

# 清除字典中所有元素
scores.clear()
print(scores)  # {}

# 往字典中新增元素
scores['陈六'] = 98
print(scores)  # {'陈六': 98}

# 修改元素
scores['陈六'] = 100
print(scores)  # {'陈六': 100}

# 获取字典视图
scores = {'张三': 100, '李四': 98, '王五': 45}
# 获取字典中所有的key
keys = scores.keys()
print(keys, type(keys))  # dict_keys(['张三', '李四', '王五']) 
print(list(keys))  # ['张三', '李四', '王五'] 将dict_keys转化为list类型

# 获取字典中所有的value
values = scores.values()
print(values, type(values))  # dict_values([100, 98, 45]) 
print(list(values))  # [100, 98, 45] 将dict_values转化为list类型

# 获取字典中所有的键值对
items = scores.items()
print(items, type(items))  # dict_items([('张三', 100), ('李四', 98), ('王五', 45)]) 
print(list(items))  # [('张三', 100), ('李四', 98), ('王五', 45)] 将dict_items转化为list类型 里面是由元组组成的

# 字典元素的遍历
for key in scores:
    print(key, scores[key], scores.get(key))
    '''
    张三 100 100
    李四 98 98
    王五 45 45
    '''

# 字典生成式
items = ['Fruits', 'Books', 'Others']
prices = [96, 78, 85]
d = {item: price for item, price in zip(items, prices)}
print(d)  # {'Fruits': 96, 'Books': 78, 'Others': 85}
d = {item.upper(): price for item, price in zip(items, prices)}
print(d)  # {'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85}
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

027 tuple元组

# 元组
# Python内置的数据结构之一，是一个不可变序列
# 不可变序列与可变序列
# 不变可变序：字符串、元组
# 不变可变序列：没有增、删，改的操作
# 可变序列：列表、字典
# 可变序列：可以对序列执行增、删、改操作，对象地址不发生更改

# 元组的创建方式
# 第一种创建方式，使用()
t = ('Python', 'world', 98)
print(t)  # ('Python', 'world', 98)
print(type(t))  # 

# ()可以省略不写，
t = 'Python', 'world', 98
print(t)  # ('Python', 'world', 98)
print(type(t))  # 

# 注意，只有一个元素时，不能省略()，并且还要加上一个,
t = (10,)

# 第二种创建方式，使用内置函数tuple()
t1 = tuple(('Python', 'world', 98))
print(t1)  # ('Python', 'world', 98)
print(type(t1))  # 

# 空元组的创建
t = ()
t = tuple()

t = (10, [20, 30], 9)
print(t)
print(type(t))
print(t[0], type(t[0]), id(t[0]))
print(t[1], type(t[1]), id(t[1]))
print(t[2], type(t[2]), id(t[2]))
# 尝试将t[1]修改为100
print(id(100))
# TypeError: 'tuple' object does not support item assignment
# t[1] = 100 # 元组是不允许修改元素的

# 元组中的元素是可变的
print(t) # (10, [20, 30], 9)
t[1].append(111)
print(t) # (10, [20, 30, 111], 9)

# 元组的遍历
for item in t:
    print(item)
    '''
    10
    [20, 30, 111]
    9
    '''
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

028 set集合

# 集合(Set)
# Python语言提供的内置数据结构
# 与列表、字典立样都属于可变类型的序列
# 集合是没有value的字典
# 集合中的元素是无序的
# 集合中的元素会“自动去重”

# 第一种创建方式使用{}
s = {2, 3, 4, 5, 5, 6, 7, 7}  # 集合中的元素不允许重复
print(s)  # {2, 3, 4, 5, 6, 7}
# 第二种创建方式使用set()
s1 = set(range(6))
print(s1, type(s1))  # {0, 1, 2, 3, 4, 5} 
s2 = set([1, 2, 4, 5, 5, 5, 6, 61])
print(s2, type(s2))  # {1, 2, 4, 5, 6, 61} 
s3 = set((1, 2, 4, 4, 5, 65))
print(s3, type(s3))  # {65, 1, 2, 4, 5} 
s4 = set('python')
print(s4, type(s4))  # {'t', 'h', 'y', 'p', 'n', 'o'} 

# 定义空集合
s5 = set()
# 注意不能用 {} 定义空集合，因为{}默认会认为是空字典

# 集合的判断操作
s = {10, 20, 30, 405, 60}
print(10 in s)  # True
print(100 in s)  # False
print(10 not in s)  # False
print(100 not in s)  # True

# 集合的新增操作
s.add(80)  # 一次添加一个元素
print(s)  # {10, 80, 20, 405, 60, 30}
s.update({200, 400, 300})  # 一次添加多个元素
print(s)  # {200, 10, 300, 80, 400, 20, 405, 60, 30}
s.update([100, 99, 8])
s.update((78, 64, 56))
print(s)  # {64, 99, 100, 200, 8, 10, 300, 78, 80, 400, 20, 405, 56, 60, 30}

# 集合的删除操作
s.remove(100)
print(s)  # {64, 99, 200, 8, 10, 300, 78, 80, 400, 20, 405, 56, 60, 30}
s.discard(500)
s.discard(300)
print(s)  # {64, 99, 200, 8, 10, 78, 80, 400, 20, 405, 56, 60, 30}
s.pop()
s.pop()
print(s)  # {200, 8, 10, 78, 80, 400, 20, 405, 56, 60, 30}

# 清空集合
s.clear()
print(s)  # set()

# 判断两个集合是否相等
s1 = {1, 2, 3, 4}
s2 = {4, 3, 2, 1}
print(s1 == s2, s1 != s2)  # True False

# 判断集合A是否是集合B的子集
a = {1, 2}
b = {4, 3, 2, 1}
print(a.issubset(b))  # True

# 判断集合A是否是集合B的超集（父集）
a = {4, 3, 2, 1}
b = {4, 3}
print(a.issuperset(b))  # True

# 判断两个集合有没有交集(有交集为False，没有交集为True)
a = {1, 2, 3}
b = {3, 6, 8}
print(a.isdisjoint(b))  # False : 有交集

# 集合的数学操作
# 1.交集
s1 = {10, 20, 30, 40}
s2 = {20, 30, 40, 50, 60}
print(s1.intersection(s2))  # {40, 20, 30}
print(s1 & s2)  # {40, 20, 30}

# 2.并集
print(s1.union(s2))  # {40, 10, 50, 20, 60, 30}
print(s1 | s2)  # {40, 10, 50, 20, 60, 30}

# 3.差集(s1有，s2没有的元素集合)
print(s1.difference(s2))  # {10}
print(s1 - s2)  # {10}

# 4.对称差集(a与b的差集和b与a的差集的并集)
print(s1.symmetric_difference(s2))  # {50, 10, 60}
print(s1 ^ s2)  # {50, 10, 60}

# 集合生成式
s = {i * i for i in range(10)}
print(s, type(s))  # {0, 1, 64, 4, 36, 9, 16, 49, 81, 25} 
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

029 str字符串常用操作

# 1.字符串查询操作
s = 'hello,hello'
# 返回正向索引
print(s.index('lo'))  # 3
print(s.find('lo'))  # 3
# 返回逆向索引
print(s.rindex('lo'))  # 9
print(s.rfind('lo'))  # 9

# print (s.index('k')) # ValueError:substring not found
print(s.find('k'))  # -1
# print (s.rindex('k')) # ValueError:substring not found
print(s.rfind('k'))  # -1

# 2.字符串大小写转换操作
# upper() 把字符串中所有字符都转成大写字母
# lower() 把字符串中所有字符都转成小写字母
# swapcase() 把字符串中所有大写字母转成小写字母，把所有小写字母都转成大写字母
# capitalize() 把第一个字符转换为大写，把其余字符转换为小写
# title() 把每个单词的第一个字符转换为大写，把每个单词的剩余字符转换为小写
s = 'hello,python'
a = s.upper()
print(a, id(a))  # HELLO,PYTHON 1812798823664
print(s, id(s))  # hello,python 1812798823536
print(s.lower(), id(s.lower()))  # hello,python 1812798823792
print(s, id(s.lower()))  # hello,python 1812798823728

# 3.字符串内容对齐操作
# center()居中对齐，第1个参数指定宽度，第2个参数指定填充符，第2个参数是可选的，默认是空格，如果设置宽度小于实际宽度则则返回原字符串
# ljust()左对齐，第1个参数指定宽度，第2个参数指定填充符，第2个参数是可选的，默认是空格如果设置宽度小于实际宽度则则返回原字符串
# rjust()右对齐，第1个参数指定宽度，第2个参数指定填充符，第2个参数是可选的，默认是空格如果设置宽度小于实际宽度则则返回原字符串
# zfill() 右对齐，左边用0填充，该方法只接收一个参数，用于指定字符串的宽度，如果指定的宽度小于等于字符串的长度，返回字符串本身
s = 'hello,Python'
print(s.center(20, '*'))  # ****hello,Python****
print(s.ljust(20, '*'))  # hello,Python********
print(s.rjust(20, '*'))  # ********hello,Python
print(s.zfill(20))  # 00000000hello,Python

# 4.字符串劈分操作
# split()
# 从字符串的左边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表
# 以通过参数sep指定劈分字符串是的劈分符
# 通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独做为一部分
s = 'hello world Python'
lst = s.split()
print(lst)  # ['hello', 'world', 'Python']
s1 = 'hello|world|Python'
print(s1.split(sep='|'))  # ['hello', 'world', 'Python']
print(s1.split(sep='|', maxsplit=1))  # ['hello', 'world|Python']
# rsplit()
# 从字符串的右边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表
# 以通过参数sep指定劈分字符串是的劈分符
# 通过参数maxsplit:指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独做为一部分
print(s.rsplit())  # ['hello', 'world', 'Python']
print(s1.rsplit('|'))  # ['hello', 'world', 'Python']
print(s1.rsplit(sep='|', maxsplit=1))  # ['hello|world', 'Python']

# 5.判断字符串的操作
# isidentifier() 判断指定的字符串是不是合法的标识符
print("hello".isidentifier())  # True
# isspace() 判断指定的字符串是否全部由空白字符组成（回车、换行，水平制表符）
print("  ".isspace())  # True
# isalpha() 判断指定的字符串是否全部由字母组成
print("add".isalpha())  # True
# isdecimal() 判断指定字符串是否全部由十进制的数字组成
print("12".isdecimal())  # True
# isnumeric() 判断指定的字符串是否全部由数字组成
print("588585".isnumeric())  # True
# isalnum() 判断指定字符串是否全部由字母和数字组成
print("hello666".isalnum())  # True

# 6.字符串的替换
# replace() 第1个参数指定被替换的子串，第2个参数指定替换子串的字符串，
# 该方法返回替换后得到的字符串，替换前的字符串不发生变化，调用该方法时可以通过第3个参数指定最大替换次数
s = 'hello,Python'
print(s.replace('Python', 'Java'))  # hello,Java
s1 = 'hello,Python,Python,Python'
print(s1.replace('Python', 'Java', 2))  # hello,Java,Java,Python

# 7.字符串的合并
# join() 将列表或元组中的字符串合并成一个字符串
lst = ['hello', 'java', 'Python']
print('|'.join(lst))  # hello|java|Python
print(''.join(lst))  # helloJavaPython
t = ('hello', 'Java', 'Python')
print(''.join(t))  # helloJavaPython

# 8.字符串的比较操作
# 运算符：>，>=，<，<=，==，=
# 比较规则：首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个
# 字符串的比较结果，两个字符串中的所有后续字符将不再被比较
# 比较原理：两上字符进行比较时，比较的是其ordinal value(原始值)，调用内置函数ord可以得到指定字符的ordinal value。与内置函数ord对应的是内置函数chr,
# 调用内置函数chr时指定ordinal value可以得到其对应的字符
print('apple' > 'app')  # True
print('apple' > 'banana')  # False,相当于97>98>False
print(ord('a'), ord('b'))  # 97 98
print(ord('杨'))  # 26472
print(chr(97), chr(98))  # a b
print(chr(26472))  # 杨

'''
==与is的区别
== 比较的是value
is 比较的是id是否相等’
'''
a = b = 'Python'
c = 'Python'
print(a == b)
# True
print(b == c)  # True
print(a is b)  # True
print(a is c)  # True
print(id(a))  # 1817191677680
print(id(b))  # 1817191677680
print(id(c))  # 1817191677680 驻留机制

# 9.字符串的切片操作
s = 'hello,Python'
s1 = s[:5]  # 由于没有指定起始位置，所以从0开始切
s2 = s[6:]  # 由于没有指定结束位置，所以切到字符串的最后一个元素
s3 = '!'
newstr = s1 + s3 + s2
print(s1)  # hello
print(s2)  # Python
print(newstr)  # hello!Python

print(s[1:5:1])  # ello 从1开始截到5（不包含5），步长为1
print(s[::2])  # hloPto 默认从0开始，没有写结束，默认到字符串的最后一个元素，步长为2，两个元素之间的索引间隔为2
print(s[::-1])  # nohtyP,olleh 默认从字符串的最后一个元素开始，到字符串的第一个元素结束，因为步长为负数

# 10.格式化字符串
# (1)%占位符
name = '张三'
age = 20
print('我叫%s,今年%d岁' % (name, age))  # 我叫张三,今年20岁
# (2).format
print('我叫{0}，今年{1}岁'.format(name, age))  # 我叫张三,今年20岁
# (3)f-string
print(f'我叫{name},今年{age}岁')  # 我叫张三,今年20岁

print('{0:.3}'.format(3.1415926))  # .3表示的是一共是3位数
print('{:.3f}'.format(3.1415926))  # .3f表示是3位小数
print('{:10.3f}'.format(3.1415926))  # 同时设置宽度和精度，一共是10位，3位是小数

# 11.字符串的编码转换
# 编码：将字符串转换为二进制数据(bytes))
s = '天涯共此时'
# b'\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1'
print(s.encode(encoding='GBK'))  # 在GBK这种编码格中一个中文占两个字节
# b'\xe5\xa4\xa9\xe6\xb6\xaf\xe5\x85\xb1\xe6\xad\xa4\xe6\x97\xb6'
print(s.encode(encoding='UTF-8'))  # 在UTF-8这种编辑格式中，个中文占三个序节
# 解码：将bytes类型的数据转换成字符串类型
# byte代表就是一个二进制数据（字节类型的数据
byte = s.encode(encoding='GBK')  # 编码
# 天涯共此时
print(byte.decode(encoding='GBK'))  # 解码
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

030 def函数

# 什么是函数
# 函数就是执行特定任和以完成特定功能的一段代码
# 为什么需要函数?
# 1.复用代码
# 2.隐藏实现细节
# 3.提高可维护性
# 4.提高可读性便于调试
# 函数的创建
'''
def 函数名（输入参数)：
    函数体
    return xxx
'''


def add(a, b):
    return a + b


print(add(1, 2))  # 3
print(add(b=2, a=1))  # 3

'''
在函数调用过程中，进行参数的传递
如果是不可变对象，在函数体的修改不会影响实参的值arg1的修改为100，不会影响n1的值
如果是可变对象，在函数体的的修改会影响到实参的值arg2的修改，append(l0),会影响到n2的值
'''


# 函数的返回值
# (1)如果函数没有返回值【函数执行完毕之后，不需要给调用处提供数据】return可以省略不写
def fun1():
    pass


# (2)函数的返回值，如果是1个，直接返回类型
def fun2():
    return 1


# (3)函数的返回值，如果是多个，返回的结果为元组
def fun3():
    return 1, 2


# 函数定义默认值参数
# 函数定义时，给形参设置默认值，只有与默认值不符的时候才需要传递实参
def fun4(a=10):
    print(a)


# 个数可变的位置参数 args为元组形式
# 定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数
def fun5(*args):
    print(args)  # (1, 2, 3)


fun5(1, 2, 3)


# 个数可变的关键字形参 args为字典形式
# 定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参
def fun6(**args):
    print(args)  # {'a': 1, 'b': 2, 'c': 3}


fun6(a=1, b=2, c=3)

'''
def fun (*args,*a):
    pass
以上代码，程序会报错，个数可变的位置参数，只能是1个
def fun (**args,**args):
    pass
以上代码，程序会报错，个数可变的关键字参数，只能是1个
def fun(**args1, *args):
    pass
以上代码，程序会报错，只能是这样的形式：fun(*args1, **args) 即位置参数必须在关键字形参之前
'''


def fun7(*args1, **args):
    pass
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