Python从入门到放弃

Python从入门到放弃

1. Python概述

2. Python开发环境安装

1. 解释器3.72下载与安装

下载地址：https://www.python.org/downloads/release/python-372/

安装注意点：勾选 Add Python 3.7 to Path

2. Pycharm社区版下载与安装

下载地址：https://www.jetbrains.com/pycharm/download/#section=windows

安装注意点：勾选.py

3. Python基础

print()函数使用

1. 直接输出数字

   print(110)	# 110
   print(123)	# 123
   

2. 输出字符串

   print('hello world')	# hello world
   print("hello world")	# hello world
   

3. 输出含有运算符的表达式

   print(3+1)	# 4
   

4. 将数据输出到文件中

   fp = open('F:/python/text.txt', 'a+')
   print('hello world', file=fp, end=' ')
   fp.close()
   

5. 更改输出结尾的形式：换行或其他（end=’*’）

   print('hello world', end='\t')
   

input()函数使用

# 从键盘键入数据
present = input('啥玩意')
print(present, type(present))

转义字符使用

# 转义字符
print('hello\nworld')  # \n换行
print('hello\tworld')  # \t换行,制表符，可能出现补充空格数量少于4个
print('hello\bworld')  # \b换行，退格
print('hello\rworld')  # \r回车
print('http:\\\\www.baidu.com')
print('输出单引号\'\'')   # \加符号

# 原字符，不希望字符串中的转义字符起作用：在字符串前加上r或R。最后一个字符不能是\
print(r'hello\n world')
print(r'hello\n world\\')

对象的布尔值

print(bool(0))  # False
print(bool(None))   # False
print(bool(''))     # False
print(bool(""))     # FalseS
print(bool([]))     # False 空列表
print(bool(list()))     # False 空列表
print(bool(()))     # False 空元组
print(bool(tuple()))     # False 空元组
print(bool({}))     # False 空字典
print(bool(dict()))     # False 空字典
print(bool(set()))     # False 空集合

print('--------除以上外均为True-------')
print(bool(True))   # True
print(bool(1))  # True
print(bool(2))  # True

数据类型

int,float,bool,str…

整型int

num1 = 100
num2 = -100
num3 = 0

print(num1, type(num1))
print(num2, type(num2))
print(num3, type(num3))
# 其他进制转换为十进制
print('二进制', 0b1111100111)
print('八进制', 0o1747)
print('十进制', 999)
print('十六进制', 0x3E7)

浮点型float

# 浮点型相加存在不精确性
p = 3.141159
print(p, type(p))

num1 = 1.1
num2 = 2.2
print(num1+num2)

# 解决方法
from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))

布尔型bool

# 布尔型可以转换位数值计算（直接使用）
f1 = True
f2 = False

print(f1, type(f1))
print(f2, type(f2))
print(f1+1)
print(f2+1)

字符串str

# 使用单引号只能表示单行数据，双引号可以表示多行数据 
str1 = 'python天下第一'
str2 = "python天下第一"
str3 = """python
天下第一"""
str4 = '''python
天下第一'''
print(str1, type(str1))
print(str2, type(str2))
print(str3, type(str3))
print(str4, type(str4))

数据类型转换

# str()
# int() （文字类和小数类字符串无法转换为整型；浮点型转换时，取整抹零）
# float() （文字无法转换；整数转换时末尾.0）
name = '张三'
age = 20

print('我叫'+name+'，今年'+str(age)+'岁')
print('我叫%s，今年%d岁' % (name, age))
print(f'我叫{name}，今年{age}岁')
print(type(name), type(age))

运算符

运算顺序

算数运算>位运算>比较运算>布尔运算>赋值运算（有括号先计算括号）

算数运算符

print(2+1)  # 3 加法运算
print(5-1)  # 4 减法运算
print(2*2)  # 4 乘法运算
print(3/2)  # 1.5 除法运算
print(3//2)  # 1 整除运算
print(11 % 2)     # 1 取余运算
print(2**3)  # 8 次幂运算
print(9//4)  # 2
print(-9//-4)   # 2

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

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

位运算

# &（按位与操作）、|（按位或操作）、<<（左移位）>>、（右移位）
print(4 & 8)
print(4 | 8)
print(4 << 1)
print(4 << 2)
print(2 >> 2)

比较运算符

# 返回值为bool型
a, b = 10, 20
print('a<b吗？', a < b)   # True
print('a<=b吗？', a <= b)     # True
a = 10
b = 10
print(id(a), id(b))	# id相同
print(a == b)	# True
print(a is b, a is not b)	# True False

布尔运算

# and、or、not、in 、not in.结果为bool型
print('------------and-------------')
a, b = 1, 2
print(a == 1 and b == 2)    # True
print(a == 1 and b != 2)    # False
print(a != 1 and b != 2)    # False

print('------------or-------------')
a, b = 1, 2
print(a == 1 or b == 2)    # True
print(a == 1 or b != 2)    # True
print(a != 1 or b != 2)    # False

print('------------not-------------')
t = True
f = False
print(not t)
print(not f)

print('------------in/not in-------------')
str1 = 'hello'
print('h' in str1, 'he' in str1, 'hl' in str1, 'h' not in str1)

赋值运算符

a = b = c = 20	# 链式赋值
a += 30	# 参数赋值
a, b = 20, 30	# 解包赋值
a, b = b, a	# 交换变量值

程序的组织结构

顺序结构

自上而下

print('-------程序开始--------')
print('1.把冰箱门打开')
print('2.把大象放进去')
print('3.把冰箱门关上')
print('-------程序结束--------')

选择结构

单分支结构

# 单分支结构
money = 1000
withdraw = int(input('请输入要取的金额'))
if money >= withdraw:
    money -= withdraw
    print(f'取款成功，余额为{money}')

# 双分支结构
# 从键盘输入一个整数，判断这个数是奇数还是偶数
num = int(input('请输入一个数'))
if num % 2 == 0:
    print('该数为偶数')
else:
    print('该数为奇数')

双分支结构

# 多分支结构
num = float(str(input('请输入一个数')))
if num > 100 or num < 0:
    print('输入有误，请从新输入')
elif num >= 90:
    print(f'{num}为A')
elif num >= 80:
    print(f'{num}为B')
elif num >= 70:
    print(f'{num}为C')
elif num >= 60:
    print(f'{num}为D')
else:
    print(f'{num}为E')

多分支结构（if嵌套）

# 多分分支结构（if嵌套）
vip = str(input('是否有会员卡？y/n'))
money = float(input('购物金额:'))
if vip == 'y':
    if money >= 200:
        print(f'打8折,付款金额为{money*0.8}')
    elif money >= 100:
        print(f'打9折,付款金额为{money*0.9}')
    else:
        print(f'不打折,付款金额为{money}')
else:
    if money >= 200:
        print(f'打9.5折,付款金额为{money*0.95}')
    else:
        print(f'不打折,付款金额为{money}')

条件表达式

# 条件表达式使用
num1 = int(input('请输入第一个整数'))
num2 = int(input('请输入第二个整数'))
"""
if num1 > num2:
    print(f'{num1}大于{num2}')
elif num1 == num2:
    print(f'{num1}与{num2}相等')
else:
    print(f'{num1}小于{num2}')
"""
print(f'{num1}大于等于{num2}' if num1 > num2 else f'{num1}小于{num2}')

pass

# pass语句下无操作
num1 = input('请输入第一个数')
num2 = input('请输入第二个数')
if num1 > num2:
    pass
    print('空操作')
else:
    print('没事')

循环结构

range()函数，整数序列

"""
range()函数的使用
    range()函数用于生成整数序列
    1.range(stop)   单参数（结束值）
    2.range(start,stop) 双参数（开始值，结束值）
    3.range(start,stop,step)    三参数（开始值，结束值，步长）
    注意点：默认设置步长为1，开始值与结束值包头不包尾
    range()函数的优点，不管数列长度有多长，都只需要存储三个参数即可
    range()函数可用于控制循环次数，rang(x)为循环x次
"""
print('-------第一种方式--------')
r1 = range(10)
print(r1)
print(list(r1))

print('-------第二种方式--------')
r2 = range(2, 10)
print(r2)
print(list(r2))

print('-------第三种方式--------')
r3 = range(2, 11, 2)
print(r3)
print(list(r3))
print(2 not in r3, 3 in r3)

while

"""
程序的组织结构
    顺序结构、选择结构、循环结构
    -循环结构（while）
    while判断N+1次，条件执行N次
"""
num = 1
while num < 10:
    print(num)
    num += 1

"""
四部循环法
    1.初始化变量
    2.条件判断
    3.条件执行体
    4.改变变量
"""
# 计算0-4之间的数的累加和

num1 = 0
num2 = 0
while num1 < 5:
    num2 += num1
    num1 += 1
print(num2)

for / for in

"""
程序的组织结构
    顺序结构、选择结构、循环结构
    -循环结构（for）
    for in遍历序列、字符串、列表...
"""
# 计算0-101的偶数和

for a in 'python':
    print(a)
print(type(a))
print(a in 'Python')

sum = 0
for _ in range(101):
    if _ % 2 == 0:
        sum += _
print(sum)

# 输出100到999之间的水仙花数
# 水仙花数：该数各位上的数的立方和的值等于该数
num = 100
while num <= 999:
    if (num // 100)**3+((num % 100) // 10)**3+(num % 10)**3 == num:
        print(num)
    num += 1

for shuiXianHua in range(100, 1000):
    if (shuiXianHua // 100)**3+((shuiXianHua // 10) % 10)**3+(shuiXianHua % 10)**3 == shuiXianHua:
        print(f'{shuiXianHua}', end=',')
print('\b为水仙花数')

break

"""
break的使用
    从键盘录入密码，最多输入3次
    遇到break跳出整个循环
"""
for a in range(3):
    pwd = int(input('请输入你的密码:'))
    if pwd == 8888:
        print('密码正确!')
        break
    else:
        print('密码错误，请重新输入!')

continue

"""
continue的使用
    输出所有1-50之间5的倍数
"""
for item in range(1, 51):
    if item % 5 == 0:
        print(item)

print('------使用continue---------')
print('1-50之间5的倍数有：', end='')
for item in range(1, 51):
    if item % 5 != 0:
        continue
    else:
        print(f'{item},', end='')
print('\b')

else

"""
else的使用
    与if，while，for搭配使用
"""
for item in range(3):
    pwd = int(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('连续错误输入密码三次！')

循环嵌套

"""
打印九九乘法表
打印直角三角形
"""
# 直角三角形
for i in range(9):
    for j in range(i+1):
        print('*', end='\t')
    print('')
print('----直角三角形结束----')

# 九九乘法表
for i in range(1, 10):
    for j in range(1, i+1):
        print(f'{j}*{i}={i*j}', end='\t')
    print('')

列表List的使用

列表存储的是id，指向元素的id列表

列表的创建

"""
List列表的使用：
    创建列表的方式
    1.使用[];
    2.使用内置函数list()
列表的特点：
    1.列表元素按顺序排列;
    2.索引映射唯一数据;
    3.列表可以存储重复数据;
    4.任意数据类型混存;
    5.根据需要动态分配和回收内存
"""
# 1.使用[]
lst1 = ['hello', 'world', 100]

# 2.使用list()函数
lst2 = list(['hello', 'world', 100])

获取的查询（index）

"""
List列表的使用
    -index()函数的使用:用于获取指定值的索引
        index()函数的特点
        1.查询列表中存在N个相同元素，只能返回相同元素的第一个索引;
        2.如果查询的元素不在列表中，则返回ValueError的异常;
        3.可以在指定的start和stop中进行查找(左包右不包)
"""
lst = ['hello', 'world', 100, 'hello']
print(lst.index('hello'))
print(lst.index('hello', 1, 4))
print(lst.index('ll'))

列表的查询（单个元素）

"""
List列表的使用
    -列表的查询操作（单个元素）
    -List[]的使用：获取指定索引的元素
        1.正向索引从0到N-1;
        2.负向索引从-1到-N;
        3.指定索引不存在，则抛出IndexError错误
"""
lst = ['hello', 'world', 100, 'hello', 'world', 102]

for item in lst:
    print(item)
print('结束')
print(lst[34])

列表的查询（多个元素）

"""
List列表的使用
    -列表的查询操作（多个元素）
    -切片操作
        1.切片的结果为原列表片段的拷贝;
        2.切片的范围：start:stop;
        3.step的默认值为1：简写为[start:stop]或[start:stop:]
        4.step为整数:
            (1).[:stop:step],切片后第一个元素为原列表第一个元素;
            (2).[start::step],切片的最后一个元素是原列表的最后一个元素;
        5.step为负数:
            (1).[:stop:step],切片后第一个元素为原列表最后一个元素;
            (2).[start::step],切片后的最后一个元素为原列表第一个元素;

"""
#       0     1     2     3     4     5     6     7
lst = ['10', '20', '30', '40', '50', '60', '70', '80']
# 1.start=1,stop=6,step=1
print(lst[1:6:1])
print(type(lst[1:6:1])) # 切片后的结果为List类型
# 2.start=1,stop=6,step可省略不写(默认为1)
print(lst[1:6:])
print(lst[1:6])
# 3.start=1,stop=6,step=2
print(lst[1:6:2])
# 4.start不写(默认为0),stop=6,step=1
print(lst[:6:1])
# 5.start=1,stop不写(默认切到最后一个元素),step=1
print(lst[1::1])
print('-------step为负数--------')
# 6.start,stop,step=-1(逆序输出原列表)
print(f'原列表:{lst}')
print(f'切片表:{lst[::-1]}')
# 7.start=7,stop省略(默认切到第一个元素),step=-1
print(lst[7::-1])
# 8.start省略(默认从最后一个元素开始),stop=0,step=-1
print(lst[:0:-1])

列表元素的判断以及遍历

in， not in ，for in

"""
List列表的使用
    -列表元素的判断以及遍历
        1.in / not in
        2.for in
"""
lst = ['hello', 'world', 100]
print(100 in lst)
print('hello' in lst)
print('h' not in lst)
for item in lst:
    print(item, end='\t')
    

列表元素的添加

append()，extend()，insert()，切片操作

"""
列表List的使用
    列表元素添加操作
        1.append()-在原列表后添加元素;
        2.extend()-在原列表后添加至少一个元素,将其他列表元素加到原列表中;
        3.insert()-在原列表任意位置前添加元素;
        4.切片操作，将原列表被切的元素用新列表代替
"""
# 1.append()
lst = [10, 20, 30]
print(f'添加前列表:{lst}')
lst.append(40)
print(f'添加后列表:{lst}')
# 2.extend()
lst2 = ['hello', 'world']
lst.extend(lst2)
print(lst)
# lst.append(lst2)
# print(lst)
# 3.insert()
lst.insert(1, 90)
print(lst)
# 4.在任意位置添加多个元素
lst3 = [10, 20, 30]
lst4 = [30, 40]
lst3[2:4:] = lst4
print(lst3)

列表元素的删除

remove()，pop()，切片，clear()，del

"""
List列表的使用
    -列表元素的删除
        1.remove的使用：
            (1).一次只删除一个元素;
            (2).如果有重复元素，删除第一个;
            (3).元素不存在则抛出异常ValueError
        2.pop的使用：
            (1).删除指定索引的元素;
            (2).指定索引不存在则抛出IndexError的异常;
            (3).不指定索引，则默认删除列表最后一个元素
        3.切片：
            lst[x:x:x]=[].一次至少删除一个元素
        4.clear
            列表元素清空
        5.del
            删除列表
"""
# 1.remove的使用
lst1 = [10, 20, 30, 40, 50, 60, 30]
lst1.remove(30)
print(lst1)
# lst.remove(90)

# 2.pop的使用
lst2 = [10, 20, 30, 40]
lst2.pop(2)
print(lst2)
lst2.pop()
print(lst2)

# 3.切片操作
lst3 = [20, 40, 60, 80]
lst3[1:3:] = []
print(lst3)

# 4.clear的使用
lst4 = ['hello']
lst4.clear()
print(lst4)

# 5.del的使用
lst5 = [10, 90]
del lst5

列表元素的修改

lst[x] = ‘’

lst[x : x : x] = [x, x, x…]

"""
List列表的使用
    -列表元素的修改
        1.一次修改一个元素  -lst[x] = '';
        2.一次修改多个元素  -lst[x:x:x] = [x, x, x...]
"""
lst = [10, 30, 30, 40, 40, 50, 60]
print(lst)
lst[1] = 20
print(lst)
lst[4::1] = [50, 60, 70]
print(lst)

列表元素的分类

sort()，sorted()

"""
List列表的使用
    -列表元素的排序
        1.sort()函数
            将列表元素从小到大排序，可以指定reserve = True/False (降序/升序)
        2.sorted()函数
            (1).不更改原列表顺序，产生新列表按顺序排序
            (2).可以指定reserve = True/False (降序/升序)
"""
# 1.sort()函数
lst1 = [90, 238, 78, 88]
print(f'排序前列表:{lst1},{id(lst1)}')
lst1.sort()
print(f'排序后列表:{lst1},{id(lst1)}')
lst1.sort(reverse=True)
print(f'排序后列表:{lst1},{id(lst1)}')
print('----------内置函数sorted()----------')
# 2.sorted()函数
lst2 = [29, 828, 90, 77]
print(f'排序前列表:{lst2},{id(lst2)}')
print(f'排序后列表:{sorted(lst2, reverse=True)},{id(sorted(lst2))}')

列表生成式

lst = [i for i in range(x)]

"""
列表生成式
    lst = [i for i in range(x)]
"""
lst = [i for i in range(2, 11, 2)]
print(lst)

字典dict的使用

"""
字典dict的使用
    字典的特点
        1.字典的所有元素都是以键值对存在，键不可以重复，值可以重复;
        2.字典的元素是无序的;
        3.键必须是不可变对象;
        4.字典可以根据需要动态伸缩;
        5.字典会浪费较大的内存，使用空间换时间的数据结构
"""

字典的创建

{}、set()

"""
字典dict的使用
    字典的创建方式
        1.使用花括号创建字典;
        2.使用内置函数创建字典
"""
# 1.使用花括号创建字典{}
scores = {'张三': 100, '李四': 90, '王五': 40}
print(scores)
# 2.使用内置函数dict()创建
scores2 = dict(张三=100, 李四=90, 王五=59)
print(scores2)
# 3.创建空字典
scores3 = {}
print(scores3)

字典元素的获取

d[]、d.get()

"""
字典dict的使用
    字典元素的获取
        1.使用[];
        2.使用get()
        两者区别：在查找不存在的键时，使用get函数返回None，使用[]抛出异常
"""
scores = {'张三': 100, '李四': 90, '王五': 40}
print(scores['张三'])
print(scores.get('张三'))
print(scores.get('蛇皮', 2))

字典元素的判断、删除、新增、修改

判断：in / not in

删除：del d[‘key’]

新增/修改：d[‘key’] = ‘xx’

"""
字典dict的使用
    1.字典元素的判断
        (1).in
        (2).not in
    2.字典元素的删除
        (1).del XXX['xxx']-删除指定键的值;
        (2).clear-清空字典中的所有元素
    3.字典元素的新增与修改
        XXX['xxx'] = xx
            若字典中有则修改，无则添加
"""
scores = {'张三': 100, '李四': 90, '王五': 40}
# 1.字典元素的判断
print('张三' in scores)
print('张三' not in scores)
print(scores['张三'])
# 2.字典元素的删除 del / clear
print(scores)
del scores['张三']
scores.clear()
print(scores)
# 3.
scores['掌声'] = 122
print(scores)
scores['掌声'] = 11
print(scores)

字典视图的获取

"""
字典dict的使用
    字典视图的获取
        1.获取所有的键;
        2.获取所有的值;
        3。获取所有的键值对
"""
scores = {'张三': 100, '李四': 90, '王五': 40}
print(scores.keys())
print(scores.values())
print(scores.items())

print(list(scores.keys()))
print(list(scores.values()))
print(list(scores.items()))

字典元素的遍历

"""
字典dict的使用
    字典元素的遍历(获取的是键)
        for item in xxx
"""
scores = {'张三': 100, '李四': 90, '王五': 40}
for item in scores:
    print(f'{item}:{scores[item]}', end='\t')

字典生成式

"""
字典dict的使用
    字典生成式
"""
items = ['Fruits', 'Books', 'Others']
prices = [100, 90, 78]
dict1 = {item.upper(): price for item, price in zip(items, prices)}
print(dict1)

元组

元组的特点

"""
元组tuple的使用
    元组的注意事项
        1.如果元组本身是不可变对象，则不能再引用其他对象;
        2.如果元组中的对象是可变对象，则可变对象的引用不允许改变，但可以改变数据
"""
t = (10, [20, 30], 9)
print(t, type(t))
t[1].extend([40, 50])
print(t, type(t))
t[1][2] = 90
print(t)

可变序列 / 不可变序列

"""
元组tuple的使用
    可变序列/不可变序列
        可变序列：列表、字典
            可以进行增、删、改操作
        不可变序列：字符串、元组
            不可进行增删改操作
"""

元组的创建

()、tuple()

"""
元组tuple的使用
    元组的创建方式
        1.使用();
            只有一个元素时，括号后加逗号
        2.使用内置函数tuple();
            括号里不能省略括号
"""
# 1.使用()
tuple1 = ('hello', 'world', 90)
tuple2 = 'hello', 'world', 90
tuple3 = ('hello',)
tuple4 = 'hello',
print(tuple1, type(tuple1))
print(tuple2, type(tuple2))
print(tuple3, type(tuple3))
print(tuple4, type(tuple4))

# 2.使用
t = tuple(('hello', 'world', 90))
print(t, type(t))

# 3.创建空列表
tuple5 = ()
print(tuple5, type(tuple5))

元组的遍历

"""
元组tuple的使用
    元组的遍历
        1.使用索引;
        2.使用for in 遍历元组
"""
t = ('hello', 'world', 90)
print(t[1])
for item in t:
    print(item)

集合

集合是无序序列，排序方式随机

集合的创建

{}、set()

"""
集合set的使用
    集合元素不可重复
    集合的创建
        1.使用{};
        2.使用内置函数set()
"""
# 1.使用花括号{}
s = {'hello', 'world', 100}
print(s, type(s))
# 2.使用内置函数set()
s1 = set(range(5))  # 将整数序列转换为集合
print(s1, type(s1))
s2 = set([2, 1, 5, 2])  # 将列表转换为集合

print(s2, type(s2))
s3 = set(('hello', 100))    # 将元组转换为集合
print(s3, type(s3))
s4 = set('python')  # 将字符串转换为集合
print(s4, type(s4))
s5 = set()
print(s5, type(s5))

集合的判断、新增、删除

判断：in /not in

新增：add()、update()

删除：remove()、discard()、pop()、clear()

"""
集合set的使用
    集合的相关操作
        1.判断操作 in / not in ;
        2.新增操作 add / update;
            (1).add()一次新增一个元素;
            (2).update([])一次可以新增多个元素
        3.删除操作 remove discard;
            (1).remove(),如果目标元素不存在，则抛出异常KeyError
            (2).discard(),如果目标元素不存在，不会抛出异常
            (3).pop(),随机删除一个元素
            (4).clear(),清空集合中所有元素
"""
s = {10, 20, 30, 40}
# 1.集合元素的判断
print(10 in s)
print(120 not in s)

# 2.集合元素的新增 add , update
print(s)
s.add(50)
print(s)
s.update([2, 90, 78])
print(s)

# 3.集合元素的删除 remove discard pop clear
s.remove(20)
print(s)
s.discard(2222)
print(s)
s.pop()
print(s)
s.clear()
print(s)

集合之间的关系

相等：=

子集：s1.issubsets2()

超集：s1.issuperset(s2)

是否无交集：s1.isdisjoint(s2)

"""
集合set的使用
    集合之间的关系
        1.两集合相等-元素相同，集合相等
        2.issubset()-一个集合为另一个集合的子集
        3.issuperset()-一个集合为另一个集合的超集
        4.isdisjoint()-两个集合是否无交集
"""
# 1.两集合相等
s1 = {10, 20, 30, 40}
s2 = {40, 10, 20, 30}
print(s1 == s2)  # True
print(s1.issuperset(s2))    # True
print(s1.issubset(s2))  # True

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

# 3.一个集合为另一个集合的超集 issuperset()
s1 = {10, 20, 30, 40, 50, 60}
s2 = {20, 30, 40, 50, 60}
s3 = {70, 90}
print(s1.issuperset(s2))    # True

# 4.两个集合是否无交集 isdisjoint()
print(s1.isdisjoint(s3))    # True

集合的数据操作

求两个集合的交集：s1.intersection(s2) / &

求两个集合的并集：s1.union(s2) / |

求两个集合的差集：s1.difference(s2) / -

求两个集合的对称差集：s1.symmeric_difference(s2) / ^

"""
集合set的使用
    集合的数学操作
        1.intersection() / & 求两个集合的交集;
        2.union() / | 求两个集合的并集;
        3.difference() / - 求两个集合的差集：
        4.symmetric_difference() / ^ 求两个集合的对称差集
"""
# 1.求两个集合的交集 intersection() / &
s1 = {10, 20, 30, 40, 50, 60}
s2 = {20, 30, 60}
print(s1.intersection(s2))
print(s1 & s2)
# 2.求两个集合的并集 union() / |
s1 = {10, 20, 30, 40}
s2 = {40, 50, 60}
print(s1.union(s2))
print(s1 | s2)
# 3.求两个集合的差集 difference() / -
s1 = {10, 20, 30, 40}
s2 = {40, 50, 60}
print(s1.difference(s2))
print(s1-s2)
# 4.求两个集合的对称差集
s1 = {10, 20, 30, 40}
s2 = {40, 50, 60}
print(s1.symmetric_difference(s2))
print(s1 ^ s2)

集合生成式

xx = {i for i in range(x)}

"""
集合set的使用
    集合生成式
        xx = {i for i in range(x)}
"""
lst1 = [i for i in range(10)]
set1 = {i for i in range(10)}
items = ['fruits', 'books']
prices = [90, 80]
dict1 = {item: price for item, price in zip(items, prices)}
print(lst1)
print(set1)
print(dict1)

列表、字典、元组、集合

数据结构	是否可变	是否可重复	是否有序	定义符号
列表（list）	可变	可重复	有序	[]
元组（tuple）	不可变	可重复	有序	()
字典（dict）	可变	key不可重复，value可重复	无序	{key:value}
集合（set）	可变	不可重复	无序	{}

字符串

字符串的驻留机制

"""
字符串的使用
    字符串的驻留机制
        字符串驻留是一种在内存中仅保存一份相同且不可变字符串的方法。
        1.驻留机制的几种情况(交互模式)
            (1).字符串的长度为0或1时;
            (2).符合标识符的字符串;
            (3).字符串只在编译时进行驻留，而非运行时
            (4).[-5, 256]之间的整数
        2.sys的intern方法强制2个字符串指向同一个对象
        3.Pycharm对字符串进行了优化处理
        4.字符串驻留机制的优缺点
            (1).当需要值相同的字符串时，可以直接从字符串池中拿来使用，比卖你频繁创建与销毁
            (2).在需要字符串拼接时，建议使用str类型的join方法，而非+，效率更高
"""
str1 = 'python'
str2 = "python"
str3 = '''python'''
print(id(str1), id(str2), id(str3))

字符串的查询操作

index()、rindex()、find()、rfind()、

"""
字符串的使用
    字符串的查询操作
        1.index()-查找子串substr第一次出现的位置，如果查找的字串不存在时，则抛出ValueError的异常；
        2.rindex()-查找子串substr最后一次出现的位置，如果查找的字串不存在时，则抛出ValueError的异常；
        3.find()-查找子串substr第一次出现的位置，如果查找的字串不存在时，则返回-1；
        4rfind()-查找子串substr最后一次出现的位置，如果查找的字串不存在时，则返回-1
"""
str1 = 'hello'
print(str1.index('he'))  # 0
print(str1.rindex('l'))  # 2
print(str1.find('222'))  # -1
print(str1.rfind('22'))  # -1

字符串的大小写转换操作

upper()、lower()、sawpcase()、capitalize()、title()、、

"""
字符串的使用
    字符串的大小写转换操作
        1.upper()-把字符串所有字符都转成大写字母;
        2.lower()-把字符串所有字符都转成小写字母;
        3.swapcase()-大写转成小写，小写转成大写;
        4.capitalize()-把第一个字符转换为大写，其他为小写;
        5.title()-把每个单词的第一个字符转换为大写，其他都为小写
"""
s = 'HEllo world'
# 1.upper()
s1 = s.upper()
print(s1)   # HELLO WORLD
# 2.lower()
s2 = s.lower()
print(s2)   # hello world
# 3.swapcase()
s3 = s.swapcase()
print(s3)   # heLLO WORLD
# 4.capitalize()
s4 = s.capitalize()
print(s4)   # Hello world
# 5.title()
s5 = s.title()
print(s5)   # Hello World

字符串内容居中方式操作

center(count, ‘’)、ljust(count, ‘’)、rjust(count, ‘’)、zfill(count)

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

print('-90'.zfill(10))      # -000000090

字符串劈分操作

split(sep=’’, maxsplit= )、rsplit(sep=’’, maxsplit= )

生成列表

"""
字符串的使用
    字符串劈分操作的方法
        1.split(sep='', maxsplit= )
            (1).从字符串的左边开始劈分，默认的劈分字符串是空格，返回的值是一个列表;
            (2).以通过参数sep指定劈分字符串时的劈分符;
            (3).通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大劈分次数后，剩余的子串会单独作为一部分
        2.rsplit(sep='', maxsplit= )
            (1).从字符串的右边开始劈分，默认的劈分字符串是空格，返回的值是一个列表;
            (2).以通过参数sep指定劈分字符串时的劈分符;
            (3).通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大劈分次数后，剩余的子串会单独作为一部分
"""
s = 'hello  world  hello  python'
print(s.split())    # ['hello', 'world', 'hello', 'python']
print(s.split(sep=' ', maxsplit=2))  # ['hello', '', 'world  hello  python']
print(s.split('l'))  # ['he', '', 'o  wor', 'd  he', '', 'o  python']

字符串判断操作

isidentifier()、isspac()e、isalpah()、isdecimal、isnumeric()、isalnum()、

"""
字符串的使用
    字符串判断的相关方法
        1.isidentifier()-判断指定字符串是否为合法的标识符;
        2.isspace()-判断指定字符串是否全部为空白字符组成（回车、换行、水平制表符）;
        3.isalpah()-判断指定字符串是否全部由字母组成;
        4.isdecimal()-判断指定字符串是否全部由十进制的数字组成;
        5.isnumeric()-判断指定字符串是否全部由数字组成;
        6.isalnum()-判断指定字符串是否全部字母和由数字组成
"""
# 1.isidentifier()-判断指定字符串是否为合法的标识符;
s1 = 'abc123'
print(s1.isidentifier())  # True

# 2.isspace()-判断指定字符串是否全部为空白字符组成（回车、换行、水平制表符）;
s2 = '\t\n'
print(s2.isspace())  # True

# 3.isalpah()-判断指定字符串是否全部由字母组成;
s3 = 'abc'
print(s3.isalpha())  # True

# 4.isdecimal()-判断指定字符串是否全部由十进制的数字组成;
s4 = '12398'
print(s4.isdecimal())   # True
# 5.isnumeric()-判断指定字符串是否全部由数字组成;
s5 = '90四Ⅰ'
print(s5.isnumeric())   # True
# 6.isalnum()-判断指定字符串是否全部字母和由数字组成
s6 = 'sjh123Ⅳ'
print(s6.isalnum())  # True

字符串的替换与合并

replace(‘oldstr’, ‘newstr’, count)、join()

"""
字符串的使用
    字符串的替换与合并
        1.replace('oldstr', 'newstr', count)-
            第一个参数指定被替换的字符;
            第二个参数指定替换子串的字符串;
            第三个参数指定最大替换次数（默认全替换）。
            注：该方法返回替换后得到的字符串，替换前的字符串不发生变化
        2.join()-将列表或元组中的字符串合并为一个字符串
"""
# 1.replace()
s = 'hello python python python'
print(s.replace('python', 'java'))  # hello java java java
# 2.join()
lst = ['hello', 'python', '90']
print(' '.join(lst))    # hello python 90
tup = ('hello', 'world')
print(' '.join(tup))    # hello world
# set1 = {'hello', 'world', '90'}
# print(' '.join(set1))

字符串的比较操作

"""
字符串的使用
    字符串的比较操作
        1.运算符 > >= < <= == !=
            == 与 is 的区别:
                ==比较的是value，is比较的是id
        2.比较规则：从左到右依此比较两字符串的字符，如果相等则继续比较，直至两字符串出现不相等字符，则输出比较结果
        3.比较原理：两字符比较时，比较的是其ordinal value();
            与ord()原始值函数相对应的是chr()函数，输入原始值可以得到对应的字符
"""
print(ord('Z'))  # 90
print(chr(90))  # Z

字符串的切片操作

"""
字符串的使用
    字符串的切片操作
        [start:stop:step]
            step为正数
                start默认第一个元素
                stop默认为最后一个元素
            step为负数
                start默认最后一个元素
                stop默认为第一个元素
"""
s = 'hello,python'
s1 = s[:5]
s2 = s[6:]
print(s1, s2)   # hello python
print(f'{s1}!{s2}')  # hello!python

格式化字符串

字符串输出方式

"""
字符串的使用
    格式化字符串
        字符串输出方式
            1.使用 % 做占位符;
            2.使用 {} 做占位符;
            3.使用f表达式
"""
# 1.使用 % 做占位符
name = '张三'
age = 90
print('我叫%s，今年%d岁' % (name, age))   # 我叫张三，今年90岁

# 2.使用{}
print('我叫{0}，今年{1}岁'.format(name, age)) # 我叫张三，今年90岁

# 3.f-string
print(f'我叫{name}，今年{age}岁')  # print(f'我叫{name}，今年{age}岁') # 

字符串精度控制

"""
字符串的使用
    格式化字符串
        字符输出精度
             % 做占位符
                1.%d
                    %xd x控制输出整数的宽度
                2.%f
                    %x.yf x控制字符宽度,y控制输出的小数的保留几位小数
"""
# 1.整数型输出控制
print('%d' % 90)    # 90
print('%4d' % 90)   #   90
print('%4d' % -9.7)  #   -9

# 2.浮点型输出控制
print('%.1f' % 90.3)    # 90.3
print('%6.1f' % 90)  #   90.0

"""
字符串的使用
    格式化字符串
        字符输出精度
             {} 做占位符
                '{0:x.y}'.format(xx)
                '{0:x.yf}'.format(xx)
                x控制宽度
                y控制输出位数
"""
print('{0:5.3}'.format(3.1415926))  #  3.14
print('{0:8.3f}'.format(3.1415926))  #    3.142

字符串的编码与解码

"""
字符串的使用
    字符串的编码与解码
        1.编码
            data = str.encode(encoding='gbk/utf-8')
        2.解码
            data.decode(encoding='gbk/utf-8')
"""
str1 = '你好，陌生人'
# 1.编码
print(str1.encode(encoding='Gbk'))  # 在GBK编码格式中，一个中文占两个字节
print(str1.encode(encoding='UTF-8'))   # 在UTF-8编码格式中，一个中文占三个字节

# 2.解码
data1 = str1.encode(encoding='gbk')
data2 = str1.encode(encoding='utf-8')
print(data1.decode(encoding='gbk'))
print(data2.decode(encoding='utf-8'))

函数

函数的创建

"""
函数的使用
    1.什么是函数:
        函数是执行特定任务、完成特定功能的一段代码
    2.为什么需要函数
        (1).复用代码;
        (2).隐藏实现细节;
        (3).提高可维护性;
        (4).提高可读性便于调试
    3.函数的创建
        def 函数名([输入参数]):
            函数体
            [return xxx]
        形参:形式参数
        实参:实际参数
"""


def calc(a, b):    # a, b为形式参数
    c = a + b
    return c


result1 = calc(10, 20)  # 位置实参
print(result1)

result2 = calc(b=20, a=10)  # 关键字实参
print(result2)

函数参数传递的内存分析

"""
函数的使用
    函数参数传递的内存分析
        1.如果是不可变对象，在函数体的修改不会影响实参的值
        2.如果是可变对象，在函数体的修改会影响实参的值
"""


def fun(arg1, arg2):
    print('arg1:', arg1)
    print('arg2:', arg2)
    arg1 = 100
    arg2.append(10)
    print('arg1:', arg1)
    print('arg2:', arg2)


n1 = 11
n2 = [22, 33, 44]
print(n1, n2)
fun(n1, n2)
print(n1, n2)

函数的返回值

"""
函数的使用
    函数的返回值:
        1.如果函数没有返回值(函数执行结束后不需要给调用处提供数据)，则return可以省略;
        2.函数的返回值如果是一个，则直接返回原类型;
        2.函数的返回值如果是多个，则返回类型为元组
"""


def fun(num):
    odd = []
    even = []
    for i in num:
        if i % 2:
            odd.append(i)
        else:
            even.append(i)
    return odd, even


print(fun([1, 2, 3, 4, 5]))
tuple1 = fun([1, 2, 3, 4, 5])
for i in tuple1:
    print(i)

函数参数定义-默认参数值

"""
函数的使用
    函数参数定义-
        默认值参数:
            在定义函数时，讲形参设置默认值
"""


def fun(a, b=10):   # b默认为10
    print(a, b)


fun(20, 34)  # 20 34

函数参数定义 *args与**args

"""
函数的使用
    函数参数定义
        1.个数可变的位置形参-*args
            (1).定义函数时，可能无法实现确定传递的位置实参的个数时，使用可变的位置参数;
            (2).使用*定义个数可变的位置形参;
            (3).结果为一个元组
        2.个数可变的关键字形参-**args
            (1).定义函数时，无法实现确定传递的关键字实参的个数时，使用可变的关键字形参;
            (2).使用**定义个数可变的关键字形参;
            (3).结果为一个字典
        3.函数中既有个数可变的位置形参，又有个数可变的关键字形参，则先定义位置形参
            (1).输出结果为一个元组和一个字典;
            (2).在传入实参时，也要按照位置参数和关键字参数的顺序传入
"""


def fun1(*args):  # 1.定义个数可变的位置形参-*args
    print(args)


def fun2(**args):   # 2.定义个数可变的关键字形参-**args
    print(args)


def fun3(*args1, **args2):
    print(args1, args2)


fun1(10)
fun2(a=90, b=10, c='张三')
fun3(10, a=10, b=20, c='张三')

函数的参数总结

"""
函数的使用
    函数参数总结
        位置形参
"""


def fun(a, b, c):   # 位置形参
    print(f'a={a}', end='\t')
    print(f'b={b}', end='\t')
    print(f'c={c}')


lst = [10, 20, 30]
dic = {'a': 10, 'b': 20, 'c': 30}
fun(10, 20, 30)  # 位置实参
fun(a=10, c=30, b=20)   # 关键字实参
fun(*lst)   # 在函数调用时，将列表的元素转换为位置实参传入
fun(**dic)  # 在函数调用时，将字典的键值对转换为关键字实参

"""
函数的使用
    函数参数总结
"""


def fun1(a, b=10):   # b为默认值参数
    print(f'a={a}', end='\t')
    print(f'b={b}')


def fun2(*args1):    # 个数可变的位置形参
    print(args1)


def fun3(**args2):   # 个数可变的关键字形参
    print(args2)


def fun4(a, b, c, d):
    print(f'a={a}', end='\t')
    print(f'b={b}', end='\t')
    print(f'c={c}', end='\t')
    print(f'd={d}')


def fun5(a, b, *, c, d):    # 在限制参数使用关键字实参参数传递时，在参数前加*
    print(f'a={a}', end='\t')
    print(f'b={b}', end='\t')
    print(f'c={c}', end='\t')
    print(f'd={d}')


fun1(10)    # a=10 b=10
fun2(10, 20, 30, 40)    # 位置实参 (10, 20, 30, 40)
fun3(a=10, b=20, c=30)  # 关键字实参 {'a': 10, 'b': 20, 'c': 30}
fun4(10, 20, 30, 40)    # 位置实参 a=10    b=20   c=30   d=40
fun4(a=10, b=20, c=30, d=40)    # 关键字实参 a=10   b=20   c=30   d=40
fun4(10, 20, c=30, d=40)    # a和b采用位置实参传递，c和d采用关键字实参传递 a=10    b=20   c=30   d=40
# fun5(10, 20, 30, 40)
fun5(10, 20, c=30, d=40)    # a=10 b=20   c=30   d=40

序号	参数的类型	函数的定义	函数的调用	备注
1	位置实参		√	*
2	关键字实参		√	**
3	默认形参	√
4	关键字形参	√
5	个数可变的位置形参	√		*
6	位置可变的关键字形参	√		**

变量的作用域

"""
函数的使用
    变量的作用域
        1.程序代码能访问该变量的区域;
        2.根据变量的有效范围可分为:
            (1).局部变量:
                在函数内定义并使用的变量，只在函数内部有效，局部变量使用global声明后变为全局变量
            (2).全局变量:
                函数体外定义的变量，可作用与函数内外
"""


def fun(a, b):
    c = a+b
    print(c)


# print(a)  a是局部变量
# print(c)
name = 'python'  # name为全局变量
print(name)


def fun2():
    print(name)


fun2()


def fun3():
    global age  # 将age转换为全局变量
    age = 20
    print(age)


fun3()
print(age)

递归函数

"""
函数的使用
    递归函数:
        1.什么是递归函数:
            如果在一个函数的函数体内调用了该函数本身，这个函数就成为递归函数
        2.递归的组成部分:
            (1).递归调用
            (2).递归终止条件
        3.递归的调用过程:
            (1).每递归调用依此函数，都会在栈内存分配一个栈帧;
            (2).每执行完一次函数，都会释放相应的空间
        4.递归的优缺点:
            (1).缺点：占用内存多，效率低下
            (2).优点：思路和代码简单
"""


def fac(num):   # 计算输入值的阶乘函数
    if num == 1:
        return 1
    else:
        sum = num*fac(num-1)
        return sum


def fib(num):   # 斐波那契数列
    if num == 2 or num == 1:
        return 1
    else:
        sum = fib(num-1)+fib(num-2)
        return sum


print(fac(2))
print(fib(5))
for i in range(1, 7):
    print(fib(i), end='\t')

Bug

Python的异常处理机制

"""
Bug
    python的异常处理机制:
        1.try except 结构
            try:
                在try中输入可能抛异常的代码
            except
                在except中输入可能出现的异常以及解决方法
        2.try except / else 结构
            try:
                在try中输入可能抛异常的代码
                在except中输入可能出现的异常以及解决方法
            else:
                输出正常结果
        3.try except / else finally
            try:
                在try中输入可能抛异常的代码
                在except中输入可能出现的异常以及解决方法
            else:
                输出正常结果
            finally:
                无论有无报错,都将执行finally中的操作
"""

# 1.try except 结构
try:
    a = int(input('请输入被除数:'))
    b = int(input('请输入除数:'))
    result = a/b
    print(result)
except ValueError:
    print('请入的数字有误！')
except ZeroDivisionError:
    print('除数不能为0！')

# 2.try except / else 结构
try:
    a = int(input('请输入被除数:'))
    b = int(input('请输入除数:'))
except BaseException as e:
    print(f'出大问题了,{e}')
else:
    print(a/b)

# 3.try except / else finally 结构
try:
    a = int(input('请输入被除数:'))
    b = int(input('请输入除数:'))
except BaseException as e:
    print(f'出大问题了,{e}')
else:
    print(a/b)
finally:
    print('运行结束！')

traceback模块

"""
Bug
    python的异常处理机制:
        traceback模块
"""
import traceback
try:
    print('-----')
    print(1/0)
except ZeroDivisionError:
    traceback.print_exc()

类与对象

类的创建

"""
类与对象
    1.类：
        (1).不同的数据类型属于不同的类
        (2).使用内置函数查看数据类型
    2.对象：
        如：100，90都是int类下包含的相似的不同个例，这些隔离成为实例或对象
类
    类的创建
        class xxx:
            pass
"""


class Student:
    pass


print(type(Student))
print(id(Student))     # <class 'type'>
print(Student)  # <class '__main__.Student'>

类的组成

"""
类
    类的组成
        (1).类属性: 直接在类下创建的变量成为类属性，被类的所有对象共享
        (2).实例方法: 在类里面的函数称为实例方法
        (3).静态方法: 使用@staticmethod修饰的方法称为静态方法，使用类名直接访问
        (4).类方法: 使用@classmethod修饰的方法称为类方法，使用类名直接访问
"""


class Student:
    # 1.直接写在类里的变量，称为类属性
    native_place = '福建'

    def __init__(self, name, age):
        self.name = name    # self.name 称为实例属性，进行了一个赋值操作，将局部变量的name赋值给实例属性
        self.name = age

    # 2.在类内定义的函数称为方法、实例方法
    def eat(self):
        print('eat')

    # 3.使用@staticmethod修饰的方法称为静态方法
    @staticmethod
    def method():
        print('使用@staticmethod修饰，所以我是静态方法')

    # 4.使用@classmethod修饰的方法称为类方法
    @classmethod
    def cm(cls):
        print('使用@classmethod修饰，所以我是类方法')

对象的创建

"""
对象
    对象的创建
        对象名 = 类名
"""


class Student:
    # 1.直接写在类里的变量，称为类属性
    native_place = '福建'

    def __init__(self, name, age):
        self.name = name    # self.name 称为实例属性，进行了一个赋值操作，将局部变量的name赋值给实例属性
        self.age = age

    # 2.在类内定义的函数称为方法、实例方法
    def eat(self):
        print('eat')

    # 3.使用@staticmethod修饰的方法称为静态方法
    @staticmethod
    def method():
        print('使用@staticmethod修饰，所以我是静态方法')

    # 4.使用@classmethod修饰的方法称为类方法
    @classmethod
    def cm(cls):
        print('使用@classmethod修饰，所以我是类方法')


stu1 = Student('张三', 20)
print(stu1.name)
print(stu1.age)
print(id(stu1))
print(type(stu1))
print(stu1)

对象的使用

"""
对象
    1.类属性的使用;
    2.类方法的使用;
    3.静态方法的使用
"""


class Student:
    # 1.直接写在类里的变量，称为类属性
    native_place = '福建'

    def __init__(self, name, age):
        self.name = name  # self.name 称为实例属性，进行了一个赋值操作，将局部变量的name赋值给实例属性
        self.age = age

    # 2.在类内定义的函数称为方法、实例方法
    def eat(self):
        print('eat')

    # 3.使用@staticmethod修饰的方法称为静态方法
    @staticmethod
    def method():
        print('使用@staticmethod修饰，所以我是静态方法')

    # 4.使用@classmethod修饰的方法称为类方法
    @classmethod
    def cm(cls):
        print('使用@classmethod修饰，所以我是类方法')


# 1.类属性的使用
print(Student.native_place)
stu1 = Student('张三', 18)
stu2 = Student('李四', 29)
print(stu1.native_place)
print(stu2.native_place)

# 2.类方法的使用方法
Student.cm()

# 3.静态方法的使用
Student.method()

对象动态绑定属性和方法

"""
类与对象
    动态绑定属性和方法
        1.动态绑定属性
            xx.shuxing = xx
        2.动态绑定方法
            def fun():
                pass
            xx.fun = fun
            xx.fun()
"""


class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self):
        print(f'{self.name},在吃饭')


stu1 = Student('张三', 29)
stu2 = Student('张三丰', 28)
stu1.eat()
stu2.eat()
# 1.为对象动态绑定属性gender
stu1.gender = '男'
print(stu1.name, stu1.age, stu1.gender)

# 2.为对象动态绑定方法


def show():
    print('函数')


stu1.show = show
stu1.show()

三大特征(封装、继承、多态)

封装

"""
面向对象的三大特点
    1.封装:提高代码的安全性
        (1).将数据(属性)和行为(方法)包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。无须关系内部的具体实现细节
        (2).在python中没有专门的修饰符用于属性的私有，如果该属性不希望再类对象外部被访问，前边使用两个"__"
    2.继承
    3.多态
"""


class Car:

    def __init__(self, brand):
        self.brand = brand

    def start(self):
        print('开车')


car = Car('BBA')
car.start()

"""
面向对象的三大特点
    1.封装:提高代码的安全性
        (1).将数据(属性)和行为(方法)包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。无须关系内部的具体实现细节
        (2).在python中没有专门的修饰符用于属性的私有，如果该属性不希望再类对象外部被访问，前边使用两个"__"
    2.继承
    3.多态
"""


class Student:

    def __init__(self, name, age):
        self.name = name
        self.__age = age

    def show(self):
        print(self.name, self.__age)


stu1 = Student('张三', 29)
stu1.show()  # 张三 29
print(stu1.name)    # 张三
print(dir(stu1))
print(stu1._Student__age)   # 29

继承

"""
面向对象的三大特点
    1.封装:提高代码的安全性
        (1).将数据(属性)和行为(方法)包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。无须关系内部的具体实现细节
        (2).在python中没有专门的修饰符用于属性的私有，如果该属性不希望再类对象外部被访问，前边使用两个"__"
    2.继承
        (1).如果一个类没有继承任何类，则默认继承object类;
        (2).Python支持多继承;
        (3).定义子类时，必须在其构造函数中调用父类的构造函数
    3.多态
"""


class Person:   # 1.Person默认继承object类
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def info(self):
        print(self.name, self.age)


class Student(Person):  # Student继承Person类
    def __init__(self, name, age, score):
        super(Student, self).__init__(name, age)
        self.score = score


class Teacher(Person):  # Teacher继承Person类
    def __init__(self, name, age, teacher_year):
        super(Teacher, self).__init__(name, age)
        self.teacher_year = teacher_year


stu1 = Student('学生一号', 26, 90)
tea1 = Teacher('教师一号', 30, 10)
stu1.info()
tea1.info()

类可多继承

class A(object):
    pass


class B(object):
    pass


class C(A, B):  # C同时继承A类与B类
    pass

object类

"""
object类
    1.object类时所有类的父类，所有类都有object类的属性和方法;
    2.内置函数dir()可以查看指定对象所有属性;
    3.Object有__str__()方法，
        用于返回一个对于“对象的描述”，
        对应于内置函数str()经常用于print()方法，帮助查看信息
        经常对__str__进行重写
"""


class Student(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f'学生:{self.name}\t年龄:{self.age}'


stu1 = Student('张三', 29)
print(dir(stu1))
print(stu1)  # 默认调用__str__

多态

"""
面向对象的三大特点
    1.封装:提高代码的安全性
        (1).将数据(属性)和行为(方法)包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。无须关系内部的具体实现细节
        (2).在python中没有专门的修饰符用于属性的私有，如果该属性不希望再类对象外部被访问，前边使用两个"__"
    2.继承:
        (1).如果一个类没有继承任何类，则默认继承object类;
        (2).Python支持多继承;
        (3).定义子类时，必须在其构造函数中调用父类的构造函数
    3.多态:
        即使不知道一个变量所引用的对象是什么类型，任然可以通过这个变量调用方法，
        在运行过程中根据变量所引用对象的类型，动态决定调用哪个方法
"""


class Animal(object):
    def eat(self):
        print('动物要吃东西')


class Dog(Animal):
    def eat(self):
        print('Dog要吃东西')


class Cat(Animal):
    def eat(self):
        print('Cat要吃东西')


class Person(object):
    def eat(self):
        print('人要吃东西')


def fun(obj):
    obj.eat()


fun(Dog())
fun(Cat())
fun(Person())

特殊属性和特殊方法

dict

"""
特殊方法和特殊属性
    1.特殊属性
        __dict__:获得类对象或实例对象所绑定的所有属性和方法的字典
    2.特殊方法
        __len__():通过重写__len__()方法，让内置函数len()的参数可以实自定义类型
        __add__():通过重写__add__()方法，可使用自定义对象具有"+"功能
        __new__():用于创建对象
        __init__():对创建的对象进行初始化
"""


class A:
    pass


class B:
    pass


class C(A, B):
    def __init__(self, name, age):
        self.name = name
        self.age = age


class D(A):
    pass


x = C('张三', 90)
print(x.__dict__)   # 获得实例对象的属性
print(C.__dict__)
print(x.__class__)
print(C.__bases__)   # 获得目标类的父类，以元组形式输出
print(C.__base__)   # 获得目标类的一个父类，按继承顺序输出
print(C.__mro__)    # 获得目标类的层次结构
print(A.__subclasses__())   # 获得目标类的子类，以列表形式输出

add的重写

"""
特殊方法和特殊属性
    1.特殊属性
        __dict__:获得类对象或实例对象所绑定的所有属性和方法的字典
    2.特殊方法
        __len__():通过重写__len__()方法，让内置函数len()的参数可以实自定义类型
        __add__():通过重写__add__()方法，可使用自定义对象具有"+"功能
        __new__():用于创建对象
        __init__():对创建的对象进行初始化
"""


class Student(object):
    def __init__(self, name):
        self.name = name

    def __add__(self, other):   # 对add进行重写
        return self.name + other.name


stu1 = Student('张三')
stu2 = Student('李四')
s1 = stu1 + stu2
s2 = stu1.__add__(stu2)
print(s1, s2)
print('--------------------')

init与new

"""
特殊方法和特殊属性
    1.特殊属性
        __dict__:获得类对象或实例对象所绑定的所有属性和方法的字典
    2.特殊方法
        __len__():通过重写__len__()方法，让内置函数len()的参数可以实自定义类型
        __add__():通过重写__add__()方法，可使用自定义对象具有"+"功能
        __new__():用于创建对象
        __init__():对创建的对象进行初始化
"""


class Person(object):

    def __new__(cls, *args, **kwargs):
        print(f'调用了new,cls的id值为{id(cls)}'.rjust(30, '*'))
        obj = super().__new__(cls)
        print(f'创建的obj对象id值为{id(obj)}'.rjust(30, '*'))
        return obj

    def __init__(self, name, age):
        print(f'调用了init,self的id值为{id(self)}'.rjust(30, '*'))
        self.name = name
        self.age = age


print(f'obj类对象的id值为{id(object)}'.rjust(29, '*'))
print(f'Person类对象的id值为{id(Person)}'.rjust(29, '*'))
xx = Person('张三', 20)
print(f'创建的对象xx的id值为{id(xx)}'.rjust(29, '*'))

浅拷贝与深拷贝

"""
类的浅拷贝与深拷贝
    1.变量的赋值操作:只是形成两个变量，实际上还是指向同一个对象;
    2.浅拷贝:Python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因此，源对象与拷贝对象会引用同一个子对象
    3.深拷贝:使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同
"""
import copy


class Disk:
    pass


class Cpu:
    pass


class Computer:
    def __init__(self, disk, cpu):
        self.disk = disk
        self.cpu = cpu


# 1.变量的赋值操作
cpu1 = Cpu()
cpu2 = cpu1
print(id(cpu1), id(cpu2), cpu1 == cpu2, cpu1 is cpu2)

# 2.类的浅拷贝
disk = Disk()
computer1 = Computer(cpu1, disk)
computer2 = copy.copy(computer1)
print(id(computer1), id(computer1.disk), id(computer1.cpu))   # 浅拷贝只有源对象与拷贝对象不同，子对象相同
print(id(computer2), id(computer2.disk), id(computer2.cpu))

# 3.类的深拷贝
computer3 = copy.deepcopy(computer1)
print(id(computer1), id(computer1.disk), id(computer1.cpu))  # 深拷贝源对象与拷贝对象不同，源对象和拷贝对象的子对象也不同
print(id(computer3), id(computer3.disk), id(computer3.cpu))

模块与包

模块简介

"""
模块:modules
    1.一个模块可以包含:
        (1).函数
        (2).类:
            类属性;
            类方法;
            静态方法;
            实例方法;
        (3).语句
    2.在Python中一个扩展名为.py的文件就是一个模块;
    3.使用模块的好处:
        (1).方便其他程序和脚本的导入和使用;
        (2).避免函数名和变量名冲突;
        (3).提高代码的可维护性；
        (4).提高代码的可重复性
"""


class Person(object):   # 类
    place = '福建'    # 类属性

    def __init__(self, name, age):
        self.name = name    # 实例属性
        self.age = age

    def fun(self):  # 实例方法
        pass

    @staticmethod   # 静态方法
    def fun2():
        pass

    @classmethod    # 类方法
    def fun3(cls):
        pass


def fun1():  # 函数
    pass


def fun2():
    pass


print('这是语句')

创建、导入模块

"""
自定义模块
    1.创建模块:
        新建一个.py文件，名称尽量不要与Python自带的标准模块名称相同
    2.导入模块:
        import 模块名称 as
        from 模块名称 import 函数/变量/类
            从该模块中精确导入函数/变量/类
"""
import math  # 导入math模块
print(id(math), type(math), math)

print(dir(math))    # 查看math模块的方法
print(math.log2(8), math.pow(2, 4), math.ceil(9.001))

from math import pi
import math
print(pi)
print(pow(2, 3))
print(math.pow(2, 3))

以主程序形式运行

在每个模块的定义中都包括一个记录模块名称的变量name，程序可以检查该变量，以确定在哪个模块中执行

"""
以主程序运行
"""
if __name__ == '__main__':  # 只有运行本py文件时，下列语句才会运行
    print('语句')

包

"""
Python的包
    1.Python的包是一个分层次的目录结构，他将一组功能相近的模块组织在一起;
    2.作用:
        (1).代码规范;
        (2).避免模块名称冲突
    3.包与目录的区别:
        包中含有_init_.py文件
        目录不包含_init_.py文件
    4.包的导入:
        import 包名.模块名 as xx
    5.包的导入的注意点:
        (1).使用import ... 只能导入包、模块
        (2).使用from ... 能导入包、模块、变量、函数
"""
import package.module_A as value_A
from package.module_B import b
print(value_A.a)
print(b)

Python中常用的内置模块

Module	Function
sys	与Python解释器机器环境操作相关的标准库
time	提供时间相关的各类函数的标准库
os	提供了访问操作系统服务功能的标准库
calendar	提供与日期相关的各种函数的标准库
urllib	用于读取来自网上的数据标准库
json	用于使用Json与序列化和反序列化对象
re	用于在字符串中执行正则表达式匹配和替换
math	提供标准算术运算函数的标准库
decimal	用于精确运算精度、有效数位和四舍五入操作的十进制运算
logging	提供了灵活的记录事件、错误、警告和调试信息等日志信息的功能

import sys
import time
import urllib.request
import math

print(sys.getsizeof(1), sys.getsizeof(0), sys.getsizeof(True), sys.getsizeof(False))    # 28 24 28 24
print(time.time(), time.localtime())    
print(urllib.request.urlopen('http://www.baidu.com').read())
print(math.pi)  # 3.141592653589793

第三方模块的安装

"""
第三方模块的安装和使用
    1.安装:
        (1).使用命令栏安装:
            ①.Ctrl + R:打开任务管理器;
            ②.输入cmd;
            ③.在命令栏中输入:pip install 模块名称;
            ④.验证:输入python - 回车 - import 模块名称 - 回车（不报错即导入成功）
        (2).使用pycharm设置安装:
            file → setting → project → python interpreter → '+' → 搜索 → install Package
    2.使用:
        import 模块名
"""
import schedule
import time


def job():
    print('---haha---')


schedule.every(2).seconds.do(job)
while True:
    schedule.run_pending()
    time.sleep(1)

1