Python 基础知识 + 个人学习 + 实时更新 -＞（个人学习记录笔记）

1.输出函数

print()

1.1 输出数字

print(520)
print(98.5)

1.2 输出字符串

print('helloworld')
print("helloworld")

1.3 输出含有运算符的表达式

print(3+1)

1.4 将数据输出文件中

将数据输出文件中，注意 ！1.所指定的盘符的存在 2.使用file=fp

# a+是以读写的方式打开文件，
# 如果存在就在文件内容的后边继续追加，不存在就创建
fp = open('D:/test.txt', 'a+')
print('helloworld',file=fp)
fp.close()

1.5 不进行换行输出

（输出内容在一行当中）

print('hello','world','Python')

---

2. 转义字符与原字符

常见的转义字符

反斜杠 		\\
单引号 		\'
双引号 		\"
换行  	 	\n
回车   		\r
水平制表位 	\t
退格			\b

2.1 \n

# 转移功能的首字母 n->newline 的首字符表示换行
print('hello\nworld')  

2.2 \t

跳转到下一个制表位 （4个字节一个制表位）
例1：跳转了3个字节

print('hello\tworld')  

例2：跳转了4个字节 （一个制表位）

print('helloooo\tworld')  

2.3 \r

\r 表示将光标的位置回退到本行的开头位置

print('hello\rworld')  

2.4 \b

\b表示将光标的位置回退一位

print('hello\bworld')  

2.5 \\

print('http:\\www.baidu.com')  

解决方案：

print('http:\\\\www.baidu.com')  

2.6 \’

print('老师说:\'大家好\'')  

2.7 原字符

原字符，不希望字符串中的转义字符起作用，就使用原字符，就是在字符串前加上r，或 R

print(r'hello\nworld')  

注意！
最后一个字符不能是反斜杠

# print(r'hello\nworld\')  错误
print(r'hello\nworld\\')  # 正确

---

3. 标识符和保留字

3.1 保留字

'False','None','True', 'and', 'as', 'assert',
'async','await', 'break','class', 'continue',
'def', 'del', 'elif','else','except',
'finally','for', 'from', 'global','if',
'import','in', 'is', 'lambda', 'nonlocal', 
'not', 'or', 'pass', 'raise','return', 
'try','while', 'with','yield'

3.2 标示符

规则

• 字母，数字，下划线
• 不用数字开头
• 不用保留字
• 严格区分大小写

---

4. 变量

4.1 变量的定义与使用

name = '玛利亚'
print(name)

变量由三部分组成

• 标识：标示对象所存储的内存地址，使用内置函数id(obj)来获取
• 类型：表示的是对象的数据类型，使用内置函数type(obj)来获取
• 值：表示对象所存储的具体数据，使用print(obj)可以将值进行打印输出

name = '玛利亚'
print('标识', id(name))
print('类型', type(name))
print('值', name)

4.2 变量的多次赋值

• 多次赋值后，变量会指向新的空间

---

5. 数据类型

5.1 常用的数据类型

• 整形类型 -> int ->98
• 浮点数类型 -> float -> 3.14159
• 布尔类型 -> bool -> True ,False
• 字符串类型 -> str -> 人生苦短，我用Python

5.2 整数类型

• 英文为interger, 简写为int ,可以表示正数，负数和零
• 整数的不同进制表示方式
  • 十进制 -> 默认的进制
  • 二进制 -> 以0b开头
  • 八进制 -> 以0o开头
  • 十六进制 -> 0x开头

n1 = 90
n2 = -76
n3 = 0

print(n1, type(n1))
print(n2, type(n2))
print(n3, type(n3))

# 整数可以表示为二进制，十进制，八进制，十六进制
print('十进制', 118)
print('二进制', 0b10101110101)
print('八进制', 0o176)
print('十六进制', 0x1EAF)

5.3 浮点类型

a = 3.14159
print(a, type(a))
n1 = 1.1
n2 = 2.2
print(n1+n2)

出现不精确问题（可能性）

解决办法：

from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))

5.4 bool类型

• 用来表示真或假的值
• True 表示真，False表示假
• 布尔值可以转化为整数
  • True -> 1
  • False -> 0

f1 = True
f2 = False
print(f1, type(f1))
print(f2, type(f2))
# 布尔值可以转成整数计算
print(f1 + 1)  # 2  1+1的结果为2 True表示1
print(f2 + 1)  # 1  0+1结果为1，False表示0

5.5 字符串类型

• 字符串又被称为不可变的字符序列
• 可以使用单引号’ ’ 双引号" " 三引号’’’ ‘’'或""" “”"来定义
• 单引号和双引号定义的字符串必须在一行
• 三引号定义的字符串可以分布在连续的多行

str1 = '人生苦短，我用Python'
str2 = "人生苦短，我用Python"
str3 = """人生苦短，
我用Python"""
str4 = '''人生苦短，
我用Python'''
print(str1, type(str1))
print(str2, type(str2))
print(str3, type(str3))
print(str4, type(str4))

5.6 数据类型转换

name = '张三'
age = 20
# 说明name与age的数据类型不同
print(type(name), type(age)) 
# print('我叫'+name+'今年,'+age+'岁')
#当将str类型与int类型连接时报错，解决方案，类型转换
print('我叫' + name + '今年,' + str(age) + '岁')

5.6.1 数据类型转换的函数

5.6.2 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)))

5.6.3 int()函数

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)))  # 将float转成int类型，截取整数部分，舍掉小数部分
# print(int(s2), type(int(s2)))  # 将str转成int类型，报错，因为字符串为小数串
print(int(ff), type(int(ff)))  # 转换为0 或者 1
# print(int(s3), type(int(s3)))  # 将str转成int类型时， 字符串必须为数字串（整数），非数字串是不允许转换的

5.6.4 float()函数

print('--------------------------------------------float()将其他类型转换为float()类型---')
s1 = '128.98'
s2 = '76.77'
ff = True
s3 = 'hello'
print(type(s1), type(s2), type(ff), type(s3),)
print(float(s1), type(float(s1)))
print(float(s2), type(float(s2)))
print(float(ff), type(float(ff)))
# print(float(s3), type(float(s3)))  # 字符串中的数据如果是非数字串，则不允许转换

---

6. Python中的注释

• 单行注释 -> 以# 开头
• 多行注释 -> 并没有单独的多行注释标记，将一对三引号之间的代码称为多杭州市
• 中文编码声明注释 -> 在文件开头加上中文声明注释，用以指定源码文件的编码格式

#
'''wen
zzz'''

---

7. input()函数

• input()基本使用方法( str类型 )

present = input('大圣想要什么礼物呢？')
print(present)

• input函数的高级使用

+连接作用

a = input('请输入一个加数')
b = input('请输入另一个加数')
print(a + b)

解决办法

a = input('请输入一个加数')
a = int(a)
b = input('请输入另一个加数')
b = int(b)
print(a + b)

a = int(input('请输入一个加数'))
b = int(input('请输入另一个加数'))
print(a + b)

---

8. Python中的运算符

常用运算符

• 算数运算符
  • 标准算数运算符
    • 加（+）
    • 减（-）
    • 乘（*）
    • 除（/）
    • 整除（//）
  • 取余运算符
    • %
  • 幂运算符
    • **
• 赋值运算符
• 比较运算符
• 布尔运算符
• 位运算符

8.1 算数运算符

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

print(9//4)
print(-9//-4)

print(9//-4)  # -3
print(-9//4)  # -3

print(9%-4)  # -3 余数=被除数-除数*商      9-（-4）*（-3）  9-12 -->-3
print(-9%4)  # 3                          -9-(-12) --->3

8.2 赋值运算符

• 执行顺序：右→左
• 支持链式赋值
  • a=b=c=20
• 支持参数赋值
  • +=、-=、*=、/=、//=、%=
• 支持系列解包赋值
  • a,b,c=20,30,40

print('------------解包赋值------------')
a, b, c = 20, 30, 40
print(a, b, c)

print('------------交换两个变量的值------------')
a, b = 10, 20
print('交换之前', a, b)
a, b = b, a
print('交换之后', a, b)

8.3 比较运算符

• ,>, <, >= , <= , !=
• ==
  • 对象value的比较
• is, is not
  • 对象的id的比较

a, b = 10, 20
print('a>b吗？', a > b)  # False
print('a<b吗？', 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)  # True

== 比较的是值 value
比较对象的标识使用 is

a = 10
b = 10
print(a == b)  # True 说明， a与b的value  相等
print(a is b)  # 说明，a与b的id标识，相等
lst1 = [11, 22, 33, 44]
lst2 = [11, 22, 33, 44]
print(lst1 == lst2)  # value  -->True
print(lst1 is lst2)  # id ---->False
print(id(lst1))
print(id(lst2))
print(a is not b)  # False a的id与b的id是不相等的
print(lst1 is not lst2)  # True id不同

8.4 布尔运算符

• and
• or
• not
• in
• not in

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  True and True ---> True
print(a == 1 or b < 2)  # True  True and False ---> True
print(a != 1 or b == 2)  # True  False and True ---> True
print(a != 1 or b != 2)  # False  False and False ---> False

print('----------------not 对bool类型操作数对运算数取反---------------------')
f = True
f2 = True
print(not f)
print(not f2)

print('----------------in 与  not in---------------------')
s = 'helloworld'
print('w' in s)
print('k' in s)
print('w' not in s)
print('k' not in s)

8.5 位运算符

（8位来看）

• 位与&
  • 对应数位都是1，结果数位才是1，否则为0
• 位或 |
  • 对应数为都是0，结果数位才是0，否则为1
• 左移位运算符<<
  • 高位溢出舍弃，低位补0 相当于乘2的n次 (n为移动位数)
• 右移位运算符>>
  • 低位溢出舍弃，高位补0 相当于除以2的n次 (n为移动位数)

8.6 运算符的优先级

1. 算数运算符
   1.1 **
   1.2 * / // %
   1.3 + -
2. 位运算
   2.1 << , >>
   2.2 &
   2.3 |
3. 比较运算符
   3.1 >, <, >= , <= , ==, !=
4. 布尔运算符
   4.1 and
   4.2 or
5. 赋值运算符
   5.1 =

---

9. 程序的组织结构

9.1 顺序结构

没什么好写的.......

9.2 选择结构

9.2.1 单分支结构

money = 1000
s = int(input('请输入取款金额:'))
if s <= money:
    money = money-s
    print('取款成功，余额为：', money)

9.2.2 双分支结构

num = int(input('请输入一个整数:'))
if num % 2 ==0:
    print(num, '是偶数')
else:
    print(num, '是奇数')

9.2.3 多分支结构

score = int(input('请输入一个成绩:'))
if score >= 90 and score <= 100:
    print('A级')
elif score >= 80 and score <= 89:
    print('B级')
elif score >= 70 and score <= 79:
    print('C级')
elif score >= 60 and score <= 69:
    print('D级')
elif score >= 0 and score <= 59:
    print('E级')
else:
    print('对不起，成员有误，不在成绩有效范围内')

简化后：

score = int(input('请输入一个成绩:'))
if 90 <= score <= 100:
    print('A级')
elif 80 <= score <= 89:
    print('B级')
elif 70 <= score <= 79:
    print('C级')
elif 60 <= score <= 69:
    print('D级')
elif 0 <= score <= 59:
    print('E级')
else:
    print('对不起，成员有误，不在成绩有效范围内')

9.2.4 嵌套if

answer = input('您是会员吗？')
money = float(input('请输入购物金额：'))
if answer == 'y':
    if money >= 200:
        print('打八折，付款金额为：', money * 0.8)
    elif money >= 100:
        print('打九折，付款金额为：', money * 0.9)
    else:
        print('不打折，付款金额为:', money)
else:
    if money >= 200:
        print('打9.5折，付款金额为：', money * 0.95)
    else:
        print('不打折，付款金额为:', money)

9.2.5 条件表达式

num_a = input('请输入一个整数')
num_b = input('请输入另一个整数')

print(str(num_a) + '大于等于' + str(num_b) if num_a >=
      num_b else str(num_a) + '小于' + str(num_b))

9.2.6 pass语句

什么都不做，就是占地方，占位符

num_a = input('请输入一个整数')
num_b = input('请输入另一个整数')
if num_a >= num_b:
    pass
else:
    pass

9.3 循环结构

9.3.1 内置函数range()

• range()函数
  • 用于生成一个整数序列
  • 创建range对象的三种方式
  • 
  • 返回值是一个迭代器对象
  • range类型的优点：不管range对象表示的整数序列有多长，所有range对象占用的内存空间都是相同的，因为仅仅需要存储start，stop和step，只有当用到range对象时，才会去计算序列中的相关元素
  • in 与 not in 判断整数序列中是否存在（不存在）指定的整数

"""第一种创建方式，只有一个参数（小括号中只给了一个数）"""
r = range(10)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],默认从0开始，默认相差1为步长
print(r)  # range(0,10)
print(list(r))  # 用于查看range对象中的整数序列   --->list是列表的意思

'''第二种创建方式，给了两个参数（小括号中给了两个参数）'''
r = range(1, 10)  # 指定了起始值，从1开始，到10结束（不包含10），默认步长为1
print(list(r))

'''第三种创建方式，给了三个参数（小括号中给了三个参数）'''
r = range(1, 10, 2)
print(list(r))

'''判断指定的整数 在序列中是否存在 in ，not in'''
print(10 in r)
print(9 in r)
print(10 not in r)

print(range(1, 20, 1))  # [1..19]
print(range(1, 101, 1))  # [1...100]

9.3.2 while循环

a = 1
while a < 10:
    print(a)
    a += 1

练习题 前100的偶数和

sum = 0
a = 1
while a <= 100:
    if a % 2 == 0:# 偶数和 | 这样是奇数和if a % 2:
        sum += a
    a += 1
print(sum)
# 2550

9.3.3 for-in 循环

for item in 'Python':
    print(item)


for i in range(10):
    print(i)

# 如果在循环体不需要使用到自定义变量，可将自定义变量写为 "_"
for _ in range(5):
    print('人生苦短，我用Python')

# 前100 的偶数和

sum = 0
for item in range(1, 101):
    if item % 2==0:
        sum += item
print(sum)

例题：水仙花数

for item in range(100, 1000):
    ge = item % 10
    shi = item // 10 % 10
    bai = item // 100
    if ge**3 + shi**3 + bai**3 == item:
        print(item, '是水仙花数')

9.3.4 break语句

结束循环结构
通常与if一起使用
没什么好写的，与C语言一样

for item in range(3):
    pwd = input('请输入密码：')
    if pwd == '8888':
        print('密码正确')
        break
    else:
        print('密码不正确')

9.3.4 continue语句

退出本次循环，进入下一次循环

for item in range(1, 51):
    if item % 5 != 0:
        continue
    print(item)

9.3.5 else语句

• else语句
  • 三种搭配
  • 

for item in range(3):
    pwd = input('请输入密码：')
    if pwd == '8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
else:
    print('对不起，三次密码均错误')

a = 0
while a < 3:
    pwd = input('请输入密码：')
    if pwd == '8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
    a += 1
else:
    print('对不起，三次密码均错误')

9.3.6 嵌套循环

for i in range(1,4):
    for j in range(1,5):
        print('*',end='\t')
    print()

for i in range(1,10):
    for j in range(1,i+1):
        print(i,'*',j,'=',i*j,end='\t')
    print()

---

10. 对象的布尔值

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

print('--------以下对象的bool值均为False------')
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('--------其他对象的bool值为True------')

可以这样写，可以直接把对象放进去判断

age = int(input('请输入您的年龄：'))
if age:
    print(age)
else:
    print('年龄为', age)

---

11. 列表

可以存储不同的数组类型 而且 多个

列表的地址原理

11.1 列表的创建

• 列表需要使用中括号[]，元素之间使用英文的逗号进行分隔
• 列表的创建方式
  • 使用中括号
  • 调用内置函数list()

lst = ['hello', 'world', 98]
lst2 = list(['hello', 'world', 98])

11.2 列表的特点

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

lst = ['hello', 'world', 98, 'hello']
print(lst)
print(lst[0], lst[-4])

11.3 列表的查询操作

获取列表中指定元素的索引

• index()
  • 如查列表中存在N个相同元素，只返回相同元素中的第一个元素的索引
  • 如果查询的元素在列表中不存在，则会抛出ValueError
  • 还可以在指定的start和stop之间进行查找

lst = ['hello', 'world', 98, 'hello']
print(lst.index('hello'))  # 如查列表中存在N个相同元素，只返回相同元素中的第一个元素的索引
# print(lst.index('Python'))  # 如果查询的元素在列表中不存在，则会抛出ValueError
# print(lst.index('hello', 1, 3))  # 还可以在指定的start和stop之间进行查找
print(lst.index('hello', 1, 4))  # 还可以在指定的start和stop之间进行查找

获取列表中的单个元素

• 获取单个元素
  • 正向索引从0到N-1 举例lst[0]
  • 逆向索引从-N到-1 举例 lst[-N]
  • 指定索引不存，抛出indexError

lst = ['hello', 'world', 98, 'hello', 'world', 234]
print(lst[2])
print(lst[-3])
# print(lst[10])

获取列表中的多个元素_切片操作

语法格式：

列表名[ start : stop : step ]

• 切片的结果 —> 愿列表片段的拷贝
• 切片的范围 —>[start,stop]
• step默认为1 —>简写为[start,stop]
• step为正数 —> [:stop:step]—>切片的第一个元素默认是列表的第一个元素----->从start开始往后计算切片
  • ------------> [start::step]—>切片的最后一个元素默认是列表的最后一个元素------>从start开始往后计算切片
• step为负数 —> [:stop:step]—>切片的第一个元素默认是列表的最后一个元素----->从start开始往前计算切片
  • ------------> [start::step]—>切片的最后一个元素默认是列表的第一个元素----->从start开始往前计算切片
    

lst = [10, 20, 30, 40, 50, 60, 70, 80]

print(lst[1:6:1])
print('原列表', id(lst))
lst2 = lst[1:6:1]
print('切的片段:', id(lst2))
print(lst[1:6])  # 默认步长为1
print(lst[1:6:])
print(lst[1:6:2])
print(lst[:6:2])
print(lst[1::2])
print("-------------------------步长为负数-------------------------")
print('原列表', lst)
print(lst[::-1])
print(lst[7::-1])
print(lst[6:0:-2])

11.4 列表元素的判断及遍历

lst = [10, 20, 'python', 'hello']
print(10 in lst)
print(100 in lst)
print(10 not in lst)
print(100 not in lst)
print("--------------------")
for item in lst:
    print(item)

11.5 列表元素的增加操作

lst = [10, 20, 30]
print('添加元素之前', lst, id(lst))
lst.append(100)
print('添加元素之后', lst, id(lst))
lst2 = ['hello', 'world']
# 向列表末尾一次添加一个元素
lst.append(lst2)  # 将lst2作为一个元素添加到列表的末尾
print(lst)

# 向列表末尾一次添加多个元素
lst.extend(lst2)
print(lst)

# 在任意位置上添加一个元素
lst.insert(1, 90)
print(lst)

# 在任意位置上至少添加一个元素
lst3 = [True, False, 'hello']
lst[1:] = lst3
print(lst)

11.6 列表元素的删除操作

lst = [10, 20, 30, 40, 50, 60, 30]
lst.remove(30)  # 从列表中溢出一个元素，如果有重复元素只移第一个元素
print(lst)
# lst.remove(100)   # ValueError: list.remove(x): x not in list

# pop 根据索引移除元素
lst.pop(1)
print(lst)

# lst.pop(5)  # IndexError: pop index out of range 如果指定的索引位置不存在，则抛出异常

lst.pop()  # 如果不指定参数，默认删除列表中最后一个元素
print(lst)

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

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

'''清除列表中的所有元素'''
lst.clear()
print(lst)

'''del语句将列表对象删除'''
# del lst  # NameError: name 'lst' is not defined
# print(lst)

11.7 列表元素的修改操作

• 列表元素的修改操作
  • 为指定索引的元素赋予一个新值
  • 为指定的切片赋予一个新值

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

11.8 列表对象的排序操作

• 列表元素的排序操作
  • 常见的两种方式
    • 调用sort（）方法，列有中的所有元素默认按照从小到大的顺序进行排序，可以指定reverse=True，进行降序 排序
    • 调用内置函数sorted（），可以指定reverse=True,进行降序排序，原列表不发生改变

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

# 指定关键字参数，将列表中的元素进行降序排序
lst.sort(reverse=True)
print(lst)
lst.sort(reverse=False)
print(lst)

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

# 指定关键字参数，将列表中的元素进行降序排序
desc_list = sorted(lst, reverse=True)
print(desc_list)

11.9 列表生成式

• 列表生成式简称“生成列表的公式”
  • 语法格式：
    
• 注意格式：“表示列表元素的表达式”中通常包含自定义变量

lst = [i for i in range(1, 10)]
print(lst)
lst = [i*i for i in range(1, 10)]
print(lst)
lst2 = [i*2 for i in range(1, 6)]
print(lst2)

12. 字典

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

12.1 字典的创建

• 最常用的方式：使用花括号
  
• 使用内置函数dict()
  

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

"""第二种创建dict()"""
student = dict(name='jack', age=20)
print(student)

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

12.2 字典元素的获取

scores = {'张三': 100, '李四': 98, '王五': 45}
"""第一种方式  使用[]"""
print(scores['张三'])
# print(scores['陈六'])  # KeyError: '陈六'报错

"""第二种方式  使用get()方法"""
print(scores.get('张三'))
print(scores.get('陈六'))  # None
print(scores.get('麻七', 99))  # 99是默认值

12.3 字典元素的增_删_改操作

scores = {'张三': 100, '李四': 98, '王五': 45}
print('张三' in scores)
print('张三' not in scores)

del scores['张三']  # 删除指定的键值对
print(scores)

# scores.clear()  # 清空字典元素
# print(scores)

scores['陈六'] = 98  # 新增元素
print(scores)

scores['陈六'] = 100  # 修改
print(scores)

12.4 获取字典视图

scores = {'张三': 100, '李四': 98, '王五': 45}

# 获取所有的键
keys = scores.keys()
print(keys)
print(type(keys))
print(list(keys))  # 将所有的key组成的视图转换成列表
print("----------------------------------------------")
values = scores.values()
print(values)
print(type(values))
print(list(values))  # 将所有的values组成的视图转换成列表
print("----------------------------------------------")
items = scores.items()
print(items)
print(type(items))
print(list(items))  # 将所有的items组成的视图转换成列表由元组()组成

12.5 字典元素的遍历

scores = {'张三': 100, '李四': 98, '王五': 45}
for item in scores:
    print(item, scores[item], scores.get(item))

12.6 字典的特点

d = {'name': '张三', 'name': '李四'}  # key不允许重复
print(d)

d = {'name': '张三', 'nikename': '张三'}  # value允许重复
print(d)

12.7 字典生成式

items = ['Fruits', 'Books', 'Others']
prices = [96, 78, 85, 120, 100]
d = {item.upper(): price for item, price in zip(items, prices)}
print(d)

13. 元组

"""可变序列  列表  字典"""
lst = [10, 20, 45]
print(id(lst))
lst.append(300)
print(id(lst))

"""不可变序列 字符串，元组"""
s = 'hello'
print(id(s))
s = s + 'world'
print(id(s))
print(s)

13.1 元组的创建

"""第一种，使用()"""
t = ('Python', 'world', 98)
print(t)
print(type(t))
print("---------------------------------")
t2 = 'Python', 'world', 98  # 省略的小括号
print(t2)
print(type(t2))
print("---------------------------------")
t3 = ('Python',)  # 只包含一个元组的元素需要使用逗号和小括号
print(t3)
print(type(t3))
print("---------------------------------")
"""第二种，使用内置函数tuple()"""
t1 = tuple(('Python', 'world', 98))
print(t1)
print(type(t1))
print("---------------------------------")
"""空元组的创建方式"""
lst = []
lst1 = list()
d = {}
dic = dict()
t4 = ()
t5 = tuple()
print('空列表', lst, lst1)
print('空字典', d, dic)
print('空元组', t4, t5)

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]))
print("----------------------------")
"""尝试将t[1]修改成100"""
print(id(100))
# t[1] = 100  # 元素不允许修改元素
"""由于[20,30]列表，而列表是可变序列，所有可以向列表中添加元素"""
t[1].append(100)  # 向列表中添加元素
print(t, id(t[1]))

13.2 元组的遍历

t=('Pyhton','world',98)
"""第一种获取元组的方式，使用索引"""
print(t[0])
print(t[1])
print(t[2])
# print(t[3]) #IndexError tuple index out of range
"""遍历元组"""
for item in t:
    print(item)

14. 集合

14.1 集合的创建

"""第一种创建方式使用{}"""
s={2,3,4,5,5,6,7,8,9} # 集合不允许重复
print(s)

"""第二种创建方式使用set()"""
s1 = set(range(6))
print(s1,type(s1))

s2 = set([1,2,4,5,5,6,6])
print(s2,type(s2))

s3 = set([1,2,4,5,5,6,65])
print(s3,type(s3))

s4 = set("python")
print(s4, type(s4))

s5 = set({12,4,34,55,66,44,4})
print(s5, type(s5))

# 定义一个空集合
s6={} # dict字典类型
print(type(s6))

s7 = set()
print(type(s7))

14.2 集合的增、删、改、查操作

# 集合元素的相关操作
s = {10,20,30,40,60}
"""集合元素的判断操作"""
print(10 in s)
print(100 in s)
print(10 not in s)
print(100 not in s)
'''集合元素的新增操作'''
s.add(80) # add一次添加一个元素
print(s)
s.update({200,400,300}) # 一次至少添加一个元素
print(s)
s.update([20,99,72])
s.update((27,43,63))
print(s)

"""集合元素的删除操作"""
s.remove(200)
print(s)
# s.remove(500) # KeyError； 500
s.discard(500)
s.discard(300)
print(s)
# s.pop(200) # pop() takes no arguments (1 given)
print(s)
s.clear()
print(s)

14.3 集合间的关系

"""两个集合是否相等（元素相同，就相等）"""
s={10,20,30,40}
s2={30,40,20,10}
print(s==s2) # True
print(s!=s2) # False

'''一个集合是否是另外一个集合的子集'''
s1 = {10,20,30,40,50,60}
s2 = {10,20,30,40}
s3 = {10,20,90}
print(s2.issubset(s1)) # True
print(s3.issubset(s1)) # False

'''一个集合是否是另一个集合的超集'''
print(s1.issuperset(s2)) # True
print(s1.issuperset(s3)) # False

'''两个集合是否有交集'''
print(s2.isdisjoint(s3)) # False  有交集为False
s4={100,200,300}

print(s2.isdisjoint(s4)) # True  没有交集为True

# (1) 交集
s1={10,20,30,40}
s2={20,30,40,50,60}
print(s1.intersection(s2))
print(s1 & s2)  # intersection()  与 & 等价，交集操作

print(s1)
print(s2)

# (2)并集操作
print(s1.union(s2))
print(s1 | s2)  # union与 | 等价， 并集操作
print(s1)
print(s2)

# (3) 差集操作
print(s1.difference(s2))
print(s1-s2)

print(s1)
print(s2)

# (4) 对称差集
print(s1.symmetric_difference(s2))
print(s1^s2)

14.3 集合的生成式

lst1 = [ i*i for i in range(6)]
print(lst1)

15. 字符串

15.1 字符串的创建和驻留机制

15.2 字符串的常用操作

15.2.1 查询方法

15.2.2 大小写转换

15.2.3 字符串内容对齐操作的方法

15.2.4 字符串劈分操作的方法

15.2.5 判断字符串操作的方法

15.2.6 字符串操作的其他方法->替换合并

15.2.7 字符串的比较操作

15.2.8 字符串的切片操作

15.2.9 格式化字符串

15.2.10 字符串的编码转换

16. 函数

16.1 函数的创建和调用

16.2 函数的参数传递

16.3 函数的返回值

16.4 函数的参数定义

16.5 变量的作用域

16.6 递归函数

阶乘

斐波那契数列

17. 异常处理机制

17.1 try except

17.2 多个except

17.3 try except else

17.4 try except else finally

17.5 常见异常类型

17.6 traceback

18. 类与对象

18.1 类的创建

18.2 对象的创建

18.3 类属性，类方法，静态方法

18.4 动态绑定属性和方法

19. 封装继承重写 多态

19.1 封装

19.2 继承

19.3 重写

19.4 object类

19.5 多态

19.6 静态语言与动态语言

19.7 特殊方法和特殊属性

19.8 类的浅拷贝与深拷贝

20. 其他

20.1 主程序

20.2 模块

20.3 编码格式

20.4 文件