1、基础概述
# Pycharm设置快捷键
（1）File-Setting-Keymap-Reformat Code-Add Keyboard Shortcut-Ctrl+Q
（2）File-Setting-Keymap-Redo-Add Keyboard Shortcut-Ctrl+Y
-----------------------
# (1)配置从阿里云下载pip
# C:\Users\HIT\AppData\Roaming\pip #打开此位置,根据自己的用户名找\AppData\Roaming
#新建\pin\pip.ini
#[global]
#index-url = http://mirrors.aliyun.com/pypi/simple/
#[install]
#trusted-host=mirrors.aliyun.com
pip install --upgrade pip #升级pip,如果报错Consider using the `--user` option or check the permissions.请注意更改python的权限,打开python所在位置,把完全控制都打上勾然后再执行
pip install pandas #可以看到从阿里云下载包
----------------------
# (2)str
""" 注释 """
s = '''长风破浪会有时,
直挂云帆济沧海。'''
print(s)
----------------------
# (3)格式化字符串
b = 'Hello %s' % '陈翔六点半'
print(b)
c = 'Hello %s Hi %s' % ('陈翔六点半', '蘑菇头')
print(c)
# fromat str
a = '哈哈'
b = '嘿嘿'
c = f'Hello {a} {b}'
print(c)
name = '陈翔'
print('欢迎 ' + name + ' 到来')
print('欢迎 %s 到来' % name)
print(f'欢迎 {name} 到来')
# copy str ,* is copy
a = 'abc'
a = a * 2
print(a)
---------------------
# (4)检查数据类型
# bool
a = True
print(a)
b = '陈翔'
print(b)
c = None
print(type(a))
print(type(b))
print(type(c))
---------------------------
# （5）对象
# see Object id
a = True
print(a)
b = '陈翔'
print(b)
c = None
print(id(a))
print(id(b))
print(id(c))
#variable
a = 10
b = a
c = a
print(str(b) + "---" + str(c))
a = 30
print(str(b) + "---" + str(c))
-----------------------------------
#（6）Centos7卸载Python2.7且安装Python3.8
（1）下载安装zlib，这是安装python3.8所需
cd /opt #切换到软件安装目录
wget http://www.zlib.net/zlib-1.2.11.tar.gz #下载
tar zxvf zlib-1.2.11.tar.gz #解压
cd zlib-1.2.11 #进入解压后目录
./configure #配置
make && make install #编译并安装
（2）安装python3.8
yum -y groupinstall "Development tools" #工具
yum -y install zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gdbm-devel db4-devel libpcap-devel xz-devel #工具
yum install libffi-devel -y #工具
wget https://www.python.org/ftp/python/3.8.3/Python-3.8.3.tgz #下包
tar -zxvf Python-3.8.3.tgz #解压
mkdir /usr/local/python3 #创建编译安装目录
cd Python-3.8.3 #切换目录
./configure --prefix=/usr/local/python3 #配置
make && make install #编译并安装
Installing collected packages: setuptools, pip #装完提示信息
Successfully installed pip-19.2.3 setuptools-41.2.0 #装完提示信息
ll /usr/bin/ |grep python # 查看当前python软连接
rm -rf /usr/bin/python #删除python软连接
ln -s /usr/local/python3/bin/python3 /usr/bin/python #添加python3的软链接
python -V #查看默认版本
rm -rf /usr/bin/pip #删除默认pip软连接
ln -s /usr/local/python3/bin/pip3 /usr/bin/pip #添加 pip3 的软链接
vim /usr/bin/yum #把 #! /usr/bin/python 修改为 #! /usr/bin/python2
vim /usr/libexec/urlgrabber-ext-down #把 #! /usr/bin/python 修改为 #! /usr/bin/python2
vim /usr/bin/yum-config-manager #!/usr/bin/python 改为 #!/usr/bin/python2
vim vim /usr/bin/firewall-cmd #修改为 #! /usr/bin/python2
yum install python-gobject #安装
yum install python-firewall #安装方可正常使用防火墙
pip3 install pyyaml #注意是pip3
--------------------------------
# （7）数据类型转换
# type convert int()、float()、str()、bool()
a = 0
a = bool(a)
print(a)
print("data type is:", type(a))
--------------------------------
# （8）算术运算符
# add, subtract, multiply and divide power modulus
a = 10 + 5
print(a, type(a))
a = 5 * 5
print(a, type(a))
a = 6 / 3
print(a, type(a))
# // only reserve int num
a = 10 // 3
print(a, type(a))
# power
a = 2 ** 5
print(a, type(a))
# modulus
a = 10 % 3
print(a, type(a))
a = 10 % 2
print(a, type(a))
-------------------------
# （9）赋值运算符
# The assignment =
a = 10
print(a, type(a))
-------------------------
# （10）关系运算符
# Relational operator
# True or False
result = 10 > 20
print(result, type(result))
result = 10 > 5
print(result, type(result))
# compare by unicode code
# because 2 unicode big then unicode,will not see left num
result = "2" > "11"
print(result, type(result))
result = "a" > "b"
print(result, type(result))
# == compare is value, not id
result = 1 == True
print(result, type(result))
# is and is not compare object id
result = False is True
print(result, type(result))
-------------------------
# （11）逻辑运算符
# Logical operator
# include and、or、not
a = True
a = not a
print(a, type(a))
# "" will return False,not a will return True
a = ""
a = not a
print(a, type(a))
# and have one False is False
# True
result = True and True
print(result, type(result))
# False
result = True and False
print(result, type(result))
# False
result = False and True
print(result, type(result))
# if first one is False,will not see second one
result = False and print("console exec?")
print(result, type(result))
result = True and print("console exec?")
print(result, type(result))
# or
# if have one True will return True
# if first one is True,will not see second one
result = False or True
print(result, type(result))
result = False or False
print(result, type(result))
--------------------------
# （12）非布尔值逻辑运算
# not bool value and or
# will as bool value deal,but return original value
# 2
result = 1 and 2
print(result, type(result))
# 0
result = 1 and 0
print(result, type(result))
# 0
result = 0 and 1
print(result, type(result))
# 1
result = 2 and 1
print(result, type(result))
# or rules
# 1
result = 1 or 0
print(result, type(result))
---------------------------
# （13）条件运算符&优先级
# Conditional operator
# statements one if condition else statements two
# see the process
# if True exec statements one
# if False exec statements two
# flag = True
flag = False
# print("Hi") if flag else print("Hello")
if flag:
print("Hi")
else:
print("Hello")
# if three variable
a = 10
b = 20
c = 30
global num_max
if a > b:
num_max = a
else:
num_max = b
if num_max > c:
num_max = num_max
else:
num_max = c
print("abc max value is:", num_max)
# The priority of the operator
# first * / then + -
a = 1 + 2 * 3
print(a, type(a))
# which high? (or and)
a = 1 or 2 and 3
print(a, type(a))
# from up, means and is high then or
# we can find from official txt too
# if you don not know, can use ()
a = 1 or (2 and 3)
print(a, type(a))
# supplement
# we can use many logical operate
result = 1 < 2 and 3 > 2 or 1 == 1
print(result, type(result))
# equal 1 < 2 and 2 < 3
result = 1 < 2 < 3
print(result, type(result))2、流程控制语句
# (1) if
# process control statements
# tow kinds: if , for while
# if condition:statements
# first judge,if True exec,False not exec
if True:
print("please guess console or not?")
num = 15
if num > 10:
print("num is big then 10")
print("no one can control me")
# from up, if only control follow statements
# if you want control more,can use code block
# code block is group for code
# code block must write in down line,please attention
# also must retract a tab or 4 blank space,but must choose one of them
if num > 10:
print("num value is", num)
print("num is big then 10")
num = 19
if 10 < num < 20:
print("num value is", num)
print("num is big then 10 and small then 20")
--------------------------
# (2) input
# input function can use to get user input
user_input = input("please input something:")
# wait for...util user input content and enter
print(user_input)
# attention,input function return is a str
if user_input == "admin":
print("welcome login ,admin")
else:
print("login failed")
# if you do not want program close,you can use input function
--------------------------
# (3)if else
# let user input age
age = input("please input your age:")
if int(age) >= 18:
print("you are adult")
else:
print("you are child")
-----------------------------
# (4) if elif else
# if-elif-else statements
# exec flow from up to down,to expression judge
# when True exec
age = 31
# if age > 200:
# print("life is so long")
# elif age > 100:
# print("you are old")
# elif age >= 60:
# print("you are not work")
# elif age >= 30:
# print("you are adult")
# else:
# print("you are child")
age = 88
if 18 <= age < 30:
print("you are adult")
elif 30 <= age < 60:
print("you are over 30, bellow 60")
else:
print("you are not young")
---
# judge num is integer or not
# num = int(input("please input a integer:"))
# if num % 2 == 0:
# print("is even number")
# else:
# print("not even number")
# year = int(input("please input year:"))
# if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
# print("is leap year")
# else:
# print("is flat year")
age = float(input("please input dog age:"))
# if dog age below 2 years
# check the age user input
# if age < 0:
# print("your input is not valid")
# elif age <= 2:
# print("dog age like person age:", age * 10.5)
# else:
# like_person_age = 2 * 10.5 + (age - 2) * 4
# print("dog age like person age:", like_person_age)
# many indentation grade
if age > 0:
if age <= 2:
print("dog age like person age:", age * 10.5)
else:
like_person_age = 2 * 10.5 + (age - 2) * 4
print("dog age like person age:", like_person_age)
else:
print("please input valid age")
# from keyboard get score
# score = float(input("please input your score(1-100):"))
# print("==================")
# # judge
# if 0 < score <= 100:
# if 100 == score < 101:
# print("BMW give you play")
# elif 100 > score >= 80:
# print("iphone play")
# elif 80 > score >= 60:
# print("book")
# else:
# print("hit you")
# else:
# print("not valid input")
# get user height money face
height = float(input("input your height:"))
money = float(input("input your money:"))
face = float(input("input your face:"))
# print(height, money, face)
if height > 180 and money > 10000 and face > 500:
print("must marry him")
elif height > 180 or money > 10000 or face > 500:
print("marry him")
else:
print("not marry him")
--------------------------------------
# （5）while
# while statements
# if you want print many many hello, how to do?
# use cycle, for and while
# if True then exec cycle body,exec body over,will continue judge util False
# dead cycle,will exec for ever
# while True:
# print("Hello")
# init expression,condition expression,update expression
# i = 0
# while i < 10:
# i = i + 1
# print("Hello", i)
# if cycle has else code ,will exec else code
i = 0
while i < 10:
i = i + 1
print("Hello", i)
else:
print("all over")
# sum all odd number small then 100
# i = 0
# result = 0
# while i < 100:
# i = i + 1
# # print(i)
# if i % 2 != 0:
# result = result + i
# print(result)
# i = 1
# while i < 100:
# print(i)
# i = i + 2
# sum all 7 multiple in 100
i = 7
result = 0
# create a count to count num
count = 0
while i < 100:
result = result + i
i = i + 7
count = count + 1
print(result, "times is", count)
# daffodils
i = 100
while i < 1000:
a = i // 100
# print(a)
b = i // 10 % 10
# print(b)
c = i % 10
# print(a, b, c)
if a ** 3 + b ** 3 + c ** 3 == i:
print(i)
i = i + 1
# is Prime Numbers or not
num = int(input("input a integer big then 1:"))
i = 2
flag = True
while i < num:
if num % i == 0:
# print(num)
flag = False
i = i + 1
if flag:
print("is prime num")
else:
print("not prime num")
-------------------------------------
# （6）cycle
# cycle nested
# control height
# i = 0
# while i < 5:
# # control width
# j = 0
# while j < 5:
# print("* ", end='')
# j = j + 1
# print()
# i = i + 1
# print triangle
# i = 0
# while i < 5:
# # control width
# j = 0
# while j < i+1:
# print("* ", end="")
# j = j + 1
# print()
# i = i + 1
i = 0
while i < 5:
# control width
j = 0
while j < 5-i:
print("* ", end="")
j = j + 1
print()
i = i + 1
# cycle nested 9 9 multiplication form
i = 0
while i < 9:
i = i + 1
j = 0
while j < i:
j = j + 1
print(f"{j}*{i}={j*i} ", end="")
print()
# Prime Numbers practice
i = 2
while i <= 100:
# print(i)
flag = True
j = 2
while j < i:
if i % j == 0:
# i can division by j,modify flag
flag = False
j = j + 1
if flag:
print(i, "is prime num")
i = i + 1
-------------------------------------------
# （7） break and continue
# break and continue
# break will terminate cycle,and quit
# i = 0
# while i < 5:
# if i == 3:
# break
# print(i)
# i = i + 1
# continue can jump current time
i = 0
while i < 5:
i = i + 1
if i == 2:
continue
print(i)
else:
print("cycle over")
# break and continue will only influence the nearly
# Prime Numbers practice
# Performance optimization
# import module,return s
from time import *
# start_time = time()
# i = 2
# while i <= 10000:
# # print(i)
# flag = True
# j = 2
# while j < i:
# if i % j == 0:
# # i can division by j,modify flag
# flag = False
# j = j + 1
# if flag:
# pass
# # print(i, "is prime num")
# i = i + 1
# end_time = time()
# print("cost time:", end_time - start_time, "s")
# cost 13.5 s
# start_time = time()
# i = 2
# while i <= 10000:
# # print(i)
# flag = True
# j = 2
# while j < i:
# if i % j == 0:
# # i can division by j,modify flag
# flag = False
# # inner cycle can stop now,use break
# break
# j = j + 1
# if flag:
# pass
# # print(i, "is prime num")
# i = i + 1
# end_time = time()
# print("cost time:", end_time - start_time, "s")
# add a break,cost time is 1.74 s
start_time = time()
i = 2
while i <= 10000:
# print(i)
flag = True
j = 2
while j <= i**0.5:
if i % j == 0:
# i can division by j,modify flag
flag = False
# inner cycle can stop now,use break
break
j = j + 1
if flag:
pass
# print(i, "is prime num")
i = i + 1
end_time = time()
print("cost time:", end_time - start_time, "s")
# 36=2*2*3*3
# cost 0.069 s
---------------------------------------
# （8）唐僧大战白骨精游戏
# welcome
print("======welcome to play game======")
print("======The Tang vs the white Bone======")
# your role
user_input = input("please choose your role:\n1、the Tang\n2、the white\nplease choose 1 or 2：")
print("---------------------------------------------")
if user_input == "1":
print("your choose is the tang")
elif user_input == "2":
print("your choose is the white,unbelievable,system decide your are the tang")
else:
print("your choose is wrong,why?,system decide your are the tang")
# 进入游戏
# 创建变量，来保存玩家的声明值和攻击力
player_life = 2
player_attack = 2
# boss的属性
boss_life = 10
boss_attack = 10
print("---------------------------------------------")
print(f"唐僧，你的生命值是{player_life}，你的攻击是{player_attack}")
print("---------------------------------------------")
# 显示游戏选项，游戏正式开始
# 由于此需要反复显示，所以必须要编写循环
while True:
print("请选择你要进行的操作：")
print("\t1.练级")
print("\t2.打boss")
print("\t3.逃跑")
user_input = input("请选择要做的操作[1-3]：")
# 处理用户的选择
if user_input == "1":
# 增加声明和攻击
player_life = player_life + 2
player_attack = player_attack + 2
print("---------------------------------------------")
# 显示玩家信息
print(f"唐僧，恭喜你升级了，你现在的生命值是{player_life}，你的攻击力是{player_attack}")
elif user_input == "2":
# 玩家攻击boss，减去boss声明值，减去玩家的攻击力
boss_life = boss_life - player_life
print("唐僧攻击了白骨精")
# 检查boss是否死亡
if boss_life <= 0:
# boss死亡，玩家胜利，游戏结束
print(f"白骨精受到了{player_attack}点伤害，死了，唐僧赢得了胜利")
break
# boss反击玩家
player_life = player_life - boss_attack
print("白骨精攻击了唐僧")
if player_life <= 0:
print(f"你精受到了{boss_attack}点伤害，死了，你输了，游戏结束")
break
elif user_input == "3":
print("唐僧跑了，游戏结束")
break
else:
print("输入有误，请重新输入")
3、列表
# --------------------------------------------------------
# （1）列表list概述
# 数值只能保存单一的数据
# 列表可以保存多个有序的数据
# 列表的创建与数据操作 []
# my_list = [] # 空列表
# print(my_list, type(my_list))
# # 列表汇总存的数据，我们称为元素，一个列表可以存储多个元素
# # 可以在创建列表时指定列表中的元素
# # 列表时用来存储对象的对象
# my_list = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1] # 创建包含10个元素的列表
# print(my_list)
# # 列表中可以保存任意的对象
# my_list = [10, "Hello", True, None, [1, 2, 3], print]
# print(my_list)
# # 列表中的对象都会按照插入的顺序进行存储
# my_list = [10, 20, 30, 40, 50]
# # 可以通过索引来获取列表中的元素，索引是从0的位置开始的
# print(my_list[2])
# # 获取列表的长度，获取到的长度的值是列表的最大索引+1
# print(len(my_list))
# --------------------------------------------------------
# # （2）切片，从现有的列表中获取一部分
# studentList = ["赵云", "刘备", "诸葛亮"]
# # 添加元素
# # studentList.append("张飞")
# print(studentList)
# # 包括起点位置元素，不包括结束位置元素
# print(studentList[1:2])
# # 如果结束位置不写，则切到最后
# print(studentList[1:])
# # 如果不写开始位置，则从第0个开始截取
# print(studentList[:2])
# # 开始结尾都省略，则全部截取
# # 步长，每次获取元素的间隔，默认值为1
# print(studentList[0:3:1])
# print(studentList[0:3:2])
# # 步长可以为负数，但是不能为0，如果是负数，则列表倒过来取值
# print(studentList[::-1])
# # 切片不会对原来的列表产生影响
# print(studentList)
# --------------------------------------------------------
# （3）通用操作
# # +可以把两个拼接成一个
# my_list = [1, 2, 3] + [4, 5, 6]
# print(my_list)
# # 重复5次
# my_list = [1, 2, 3] * 5
# print(my_list)
# # in和not in
# # 存在返回True，不存在返回False
# status = ["孙悟空", "沙和尚", "沙和尚", "沙和尚", "牛魔王"]
# print("沙和尚" in status)
# print("陈翔" in status)
# # len 获取列表中元素的格式
# # min获取列表中的最小值，max获取类表中的最大值
# array = [0, 1, 2, 7, 8, 9]
# print(min(array))
# print(max(array))
# # index() 获取指定元素在列表中的位置，获取列表中没有的会报错，第二个参数表示查找的位置
# # count()
# # 方法和函数基本上是一样的，方法必须通过对象.方法()形式调用；方法就是和对象关系紧密的函数
# print(status.index("沙和尚"))
# # print(status.index("陈翔"))
# print(status.count("沙和尚"))
# --------------------------------------------------------
# （4）序列：Python中最基本的一种数据结构
# # 序列用于保存一组有序的数据，所有的数据在我们的序列当中都有唯一的位置（索引）
# # 并且序列中会按照提添加的顺序分配索引
# # 序列的分类，可变序列list，不可变序列str、元祖tuple
# # 可变序列序列中的元素可以改变
# string = "123"
# # string[0]="3" 会报错
# array = [1, 2, 3]
# array[0] = 3 # 不会报错
# print(array)
# del array[2]
# print(array)
# # 切片修改，可以传多余切片的数量
# array[0:2] = [6, 7, 8, 9]
# # 向0的位置插入一个元素
# array[0:0] = [11]
# print(array)
# # 通过切片删除，两种操作方式
# del array[0:2]
# print(array)
# array[0:2] = []
# print(array)
# # 以上操作仅适用于可变序列
# # 不可变序列无法通过索引修改，可以通过list()函数将其他序列转换为list
# string = "Hello"
# my_list = list(string)
# print(my_list, type(my_list))
# --------------------------------------------------------
# （5）列表的方法
# students = ["猪八戒", "张飞", "赵云", "诸葛亮"]
# print("原列表: ", students)
# students.append("唐僧")
# print("append修改后: ", students)
# students.insert(2, "马超")
# print("insert修改后: ", students)
# students.extend(["宋江", "贾宝玉"])
# print("extend修改后: ", students)
# # students.clear()
# # print("clear修改后: ",students)
# # 除了删除，还能返回，不写参数删除最后一个元素
# reslut = students.pop(2)
# print("pop修改后: ", students, " ;", reslut)
# # 根据值删除的，如果相同值有多个，只会删除第一个
# students.remove("猪八戒")
# print("remove修改后: ", students)
# # reverse() 反转列表
# students.reverse()
# print("reverse修改后: ", students)
# # sort() 对列表中的元素进行排序
# my_list = list("adfkjasdfjkladflsk")
# print("修改前: ", my_list)
# my_list.sort()
# print("sort修改后: ", my_list)
# my_list.sort(reverse=True)
# print("sort修改后: ", my_list)
# --------------------------------------------------------
# （6）遍历列表
# students = ["猪八戒", "张飞", "赵云", "诸葛亮"]
# i = 0
# # 用的不多
# # while i < len(students):
# # print(students[i])
# # i = i + 1
# # 主要用这种 for循环
# # for循环序列中有几个元素就执行几次，每执行一次就会将序列中的元素赋值给变量
# for temp in students:
# print(temp)
# --------------------------------------------------------
# （7）员工的增删改查employee manager system
# print("-" * 20, "欢迎使用员工管理系统", "-" * 20)
# # 创建列表，保存信息，员工信息以字符串形式报错
# employee_list = ["赵云-----18-----男-----蜀国", "张飞-----19-----男-----蜀国"]
# while True:
# print("请选择要做的操作：\n"
# "\t1.查询员工\n"
# "\t2.添加员工\n"
# "\t3.删除员工\n"
# "\t4.退出系统")
# user_input = input("请选择（1-4）：")
# print("-" * 62)
# # 根据用户选择来做操作
# if user_input == "1":
# # 查询员工
# print("序号-----姓名-----年龄-----性别-----住址")
# n = 1
# for temp in employee_list:
# print(f"{n}-----{temp}")
# n = n + 1
# pass
# elif user_input == "2":
# # 添加员工
# # 获取添加员工的信息
# name_input = input("添加员工姓名：")
# age_input = input("添加员工年龄：")
# sex_input = input("添加员工性别：")
# address_input = input("添加员工住址：")
# # 将信息拼接为字符串，然后插入到列表中
# employee = f"{name_input}-----{age_input}-----{sex_input}-----{address_input}"
# print("以下员工将被添加到系统中")
# print("-" * 62)
# print("姓名-----年龄-----性别-----住址")
# print(employee)
# print("-" * 62)
# user_confirm = input("是否确认该操作[y/N]?")
# if user_confirm == "y" or user_confirm == "yes":
# employee_list.append(employee)
# print("恭喜，添加成功")
# pass
# else:
# print("添加操作取消")
# pass
# elif user_input == "3":
# # 删除员工
# user_input_delete_number = int(input("请输入删除员工的序号："))
# # 判断序号是否有效
# if 0 < user_input_delete_number <= len(employee_list):
# delete_index = user_input_delete_number - 1
# print("以下员工将被删除")
# print("-" * 62)
# print("姓名-----年龄-----性别-----住址")
# print(employee_list[delete_index])
# print("-" * 62)
# user_confirm = input("是否确认该操作[y/N]?")
# if user_confirm == "y" or user_confirm == "yes":
# employee_list.pop(delete_index)
# print("恭喜，删除成功")
# pass
# else:
# print("删除操作取消")
# pass
# else:
# print("您的输入有误，请重新操作！")
# pass
# elif user_input == "4":
# input("感谢使用，再见，点击回车退出")
# break
# else:
# print("您的输入有误，请重新输入")
# print("-" * 62)
# --------------------------------------------------------
# （8）range()是一个函数，可以用来生成一个自然数序列
# range_list = range(6)
# print(list(range_list))
# # 起始位置 结束位置 步长
# range_list = range(0, 10, 2)
# print(list(range_list))
# # 通过range可以创建指定次数的for循环
# for i in range(10):
# print(i)
# for循环除了创建方式外，其余都和while一样，包括else break continue
# --------------------------------------------------------
# （9）元组tuple是不可变序列，当成不可变的列表即可
# 希望数据不被改变时，就使用元组
# my_tuple = ()
# print(my_tuple, type(my_tuple))
# my_tuple = (1, 2, 3, 4, 5)
# print(my_tuple, type(my_tuple), my_tuple[0])
# # 当元组不是空是，括号可以省略
# # 如果元组不是空，元组里至少有一个逗号
# my_tuple = 10, 20, 30, 40
# print(my_tuple, type(my_tuple))
# my_tuple = 10, 20, 30, 40
# # 元组的解包（解构），即将元组当中的每一个元素都赋值给一个变量
# a, b, c, d = my_tuple
# print(a, b, c, d)
# a = 100
# b = 300
# print(a, b)
# # a、b交换值，这时可以利用元组
# a, b = b, a
# print(a, b)
# # 在解包时，变量数量要和元素的数量一直
# # 也可以在变量前，添加星号，这样*b将获取所有剩余的元素
# my_tuple = 10, 20, 30, 40
# a, *b = my_tuple
# print(a, b)
# my_tuple = 10, 20, 30, 40
# a, *b, c = my_tuple
# print(a, b, c)
# --------------------------------------------------------
# （10）可变对象
# id(标识）type(类型) value(值)，是指的值可变，而且限于可变对象
# 比如列表就是可变对象
# a = [1, 2, 3]
# print(a, id(a))
# a[0] = 10 # 修改对象
# print(a, id(a)) # id没有变
# a = [4, 5, 6] # 改变量
# print(a, id(a)) # id变了
# # 修改pycharm的格式化快捷键为Ctrl+Q
# # file-setting-keymap-main menu-code-reformat code-add-Ctrl+Q
# a = [1, 2, 3]
# b = a
# print(a, id(a))
# print(b, id(b))
# # 修改对象时，如果有其他变量指向，其他的变量也会变化
# b[0] = 10
# print(a, id(a))
# print(b, id(b))
# # 修改变量时，发现b变化了id，但是不会影响a
# b = [7, 8, 9]
# print(a, id(a))
# print(b, id(b))
# # 在为变量赋值时，才是修改变量，其他的都是改对象
# --------------------------------------------------------
# （11）is is not == !=
# == !=比较的是对象的值是否相等
# is is not 比较的是对象的id是否相等（比较是否是同一个对象）
a = [1, 2, 3]
b = [1, 2, 3]
print(id(a), id(b))
# True
print(a == b)
# False
print(a is b)
b = a
print(a is b)
4、字典与集合
# --------------------------------------------------------
# （1）字典dict概述
# 一种新的数据结构，成为映射mapping
# 和列表类似，都是用来存储对象的容器
# 存储数据性能的很好，但是查询数据的性能很差
# 在字典中，每一个元素都有唯一的名字，通过唯一的名字可以快速查找指定的元素
# 字典中也可以保存多个对象，每一个对象都有唯一的名字
# 这个唯一的名字叫做key，这个对象叫做值value，键值对结构
# 通过key可以快速的查询value
# 每一个字段中可以有多个键值对，每一个键值对我们称为一项item
# d = {}
# print(d, type(d))
# # 这是一个空字典，字典的值可以是任意对象，字典的键可以是任意的不可变对象
# # 字典的键是不能重复的，如果出现重复后面的会替换掉前面的
# # 一般字典的键都是字符串
# d = {
# "age": 18,
# "sex": "男",
# "name": "六耳猕猴"
# }
# print(d, type(d))
# # 需要根据键来取值
# print(d["name"], d["age"])
# # print(d["hi"]) #报错
# print(d.get("name"))
# print(d.get("hi")) # 返回None，推荐用这个
# --------------------------------------------------------
# （2）字典的使用
# 语法{k1:v1,k2:v2}
# 还可以使用dict函数创建字典
# d=dict(name="孙悟空",age=18,sex="男") #每一个参数都是一个键值对
# print(d,type(d))
# 这种方式创建的字典，key都是字符串
# 也可以将包含双值子序列的序列，转换为字典
# 双值序列[1,2]"ab"
# 子序列，如果序列中的元素也是序列，那么我就称这个元素为子序列
# 例如[(1,2),(3,5)]
# d = dict([("name", "孙悟空"), ("age", 18)])
# print(d, type(d))
# # len()获取字典中键值对的个数
# print(len(d))
# # in检查是否包含指定的键
# # not in不包含指定的键
# print("Hello" in d)
# print("Hello" not in d)
# # 获取字典中的值
# print(d["name"])
# temp = "name"
# print(d[temp])
# # 通过中括号[]，如果键不存在，会抛出异常key error
# # 可以使用in判断，也可以用get来获取，就算不存在也会返回None，不会抛异常
# print(d.get("hi"))
# # 获取不到值时，会返回默认值
# print(d.get("hi", "默认值"))
# # 修改字典
# d = {
# "age": 18,
# "sex": "男",
# "name": "六耳猕猴"
# }
# d["name"] = "孙悟空"
# d["work"] = "IT" # 没有就给你加上
# print(d)
# # 如果key已经存在字典，则返回值不作操作。如果key不存在则添加key并设置value
# result = d.setdefault("name", "猪八戒")
# print(result)
# print(d)
# result = d.setdefault("Hello", "猪八戒")
# print(result)
# print(d)
# # update([other])将其他字典中的值添加到当前字典中
# d = {"a": 1, "b": 2}
# d2 = {"c": 3, "d": 4}
# d.update(d2)
# print(d)
# # 如果有重复的d2中的会替换d1中的
# # 使用del可以删除字典中的key value
# del d["a"]
# print(d)
# del d["b"]
# print(d)
# # popitem()随机删除字典中的一个键值对，一般都会删除最后一个键值对
# # 并把删除的元素返回元组tuple
# # 删除空字典会抛出异常
# result = d.popitem()
# print(result, type(result))
# print(d)
# # pop根据key删除字典中的返回值，返回的是删除的值
# # 如果删除不存在的key会抛出异常
# # 如果指定默认值，则不会报错
# result = d.pop("c")
# print(result, type(result))
# result = d.pop("c", "删除默认返回值")
# print(result, type(result))
# print(d)
# # clear
# d = {"a": 1, "b": 2}
# d.clear()
# print(d, type(d))
# # copy() 用于对字典进行浅复制
# # 复制以后的对象和原对象是独立的，修改一个不会影响另一个
# d = {"a": 1, "b": 2}
# d2 = d.copy()
# print(d2, type(d2))
# print(id(d), id(d2))
# # 这就解释了浅复制，如果内部还有个字典，内部的是不会被复制的
# d = {"a": {"name": "孙悟空"}, "b": 2}
# d2 = d.copy()
# d2["a"]["name"] = "猪八戒"
# d2["b"] = 3
# print(d, id(d))
# print(d2, id(d2))
# --------------------------------------------------------
# （3）字典的遍历
# keys()
# values()
# items()
# d = {
# "name": "孙悟空",
# "age": 18,
# "sex": "男"
# }
# # 可以通过遍历keys获取所有的键值
# print(d.keys())
# for key in d.keys():
# print(d[key])
# # values()该方法也会返回一个序列，序列中保存有字典的所有的值
# for value in d.values():
# print(value)
# # items()会返回字典中所有的项
# # 它会返回一个序列，序列中包含有双值子序列
# for item in d.items():
# key, value = item # 元组的解包
# print(key, " ", value)
# --------------------------------------------------------
# （4）集合
# 集合只能存储不可变对象
# 集合中存储的对象是无序的
# 集合中不能出现重复的元素
# 使用{}创建集合
# my_set = {10, 1, 2, 3, 4, 1, 1, 1}
# print(my_set, type(my_set))
# # collection = {[1, 2, 3], [4, 5, 6]} #这个会报错，不能存储可变对象
# my_set = set() # 空集合
# print(my_set, type(my_set))
# # 可以通过set()来将序列和字典转换为集合
# my_set = set([1, 2, 3, 4, 5, 6])
# print(my_set, type(my_set))
# my_set = set("Hello")
# print(my_set, type(my_set))
# my_set = set({
# "a": 1,
# "b": 2
# })
# print(my_set, type(my_set))
# collection = {10, 1, 2, "a", "b"}
# print("a" in my_set)
# print(len(my_set))
# # 集合加元素add
# my_set.add("20")
# print(my_set, type(my_set))
# # update将一个集合中的元素添加到当前集合中
# # 可以传递序列或字典
# s2 = set("Hello")
# my_set.update(s2)
# print(my_set, type(my_set))
# # 删除，pop随机删除一个元素
# result = my_set.pop()
# print(result, type(result))
# print(my_set, type(my_set))
# # remove，删除指定的元素
# # my_set.remove(10)
# print(my_set, type(my_set))
# # clear
# my_set.clear()
# print(my_set, type(my_set))
# copy 对集合进行浅复制
# --------------------------------------------------------
# （5）集合set的运算
# 集合和列表非常相似
# 集合中只能存储不可变对象，集合中存储的对象是无序的（不是按照元素的插入顺序）
# 集合中不能出现重复的元素
# 创建集合{} set函数都可以
my_set = {10, 1, 2, 3, 4}
my_set2 = {3, 4, 5, 6, 7}
# &交集运算
result = my_set & my_set2
print(result, type(result))
# | 并集运算
result = my_set | my_set2
print(result, type(result))
# -差集
result = my_set - my_set2
print(result, type(result))
# ^异或集，只取在一个集合中的元素
result = my_set ^ my_set2
print(result, type(result))
# <=检查A集合是否为B集合的子集，<是真子集
my_set = {1, 2}
my_set2 = {1, 2, 3}
print(my_set <= my_set2)
# >=检查A集合是否为B的超级，>真超级
my_set = {1, 2}
my_set2 = {1, 2, 3}
print(my_set2 >= my_set)
5、函数
# --------------------函数------------------------------------
# （1）函数function概述
# 函数也是一个对象
# 对象是内存中，专门用来存储数据的一块区域
# 函数可以用来保存一些可执行的代码，并且可以在需要时对这些语句进行多次调用
# 创建函数/定义函数 def函数名([参数1，参数2...])：代码块
# 定义函数
# def my_function():
# print("开始执行...")
# print("我的第一个函数")
# print("开始完毕...")
#
#
# # print(my_function, type(my_function))
# my_function()
# my_function是对象 my_function()是函数的调用
# --------------------函数------------------------------------
# （2）参数
# 定义一个函数，可以求任意两个数的和
# 函数名必须符合标识符的规范，字母、数字、下划线，不能以数字开头
# 在定义函数时，可以在函数名后的()中定义数量不等的形参、
# 形参就是形式上的参数，就相当于在函数内部声明了变量，但是并不赋值
# 实参，如果函数定义时，指定了形参，那么在调用函数也必须传递实参，实参
# 将会赋值给对应的形参
# def my_sum(a, b):
# return a + b
#
#
# print(my_sum(1, 4)) # 1和4就是实参
# print(my_sum(125, 489))
# --------------------函数------------------------------------
# （3）参数传递的方式
# def my_multiplication(a, b, c):
# return a * b * c
#
#
# print(my_multiplication(1, 4, 6))
#
#
# # 可以指定默认值
# def my_multiplication2(a, b, c=20):
# return a * b * c
#
#
# # 用户传参默认值没有用，如果不传默认值是生效的
# print(my_multiplication2(1, 4, 6))
# print(my_multiplication2(1, 4))
# # 实参的传递方式，位置参数，按照顺序赋值给参数
# # 关键字参数，可以不按照形参定义的顺序传递，而是根据参数名传递
# print(my_multiplication2(b=1, a=2, c=19)) # 不用去记忆位置了
# print(my_multiplication2(1, c=2, b=19)) # 可以混合使用
# # 混合使用，必须把位置参数放到前面，而且位置和关键字不能同时指定一个形参
# --------------------函数------------------------------------
# （4）实参的类型
# 函数在调用时，解析器不会检查实参的类型
# 实参可以传递任意类型
# def my_function(a, b, c):
# return a + b + c
#
#
# print(my_function(my_function(1, 1, 1), 2, 3))
#
#
# # 在函数中对形参进行重新复制，不会影响其他变量
# # 如果形参执行的是一个对象，我们通过形参修改对象时，会影响到所指向对象的变量
# def change(a):
# a[0] = 30
#
#
# b = [1, 2, 3]
# change(b)
# print(b, type(b)) # 和java一样
# b = [1, 2, 3]
# change(b.copy()) # 如果不想让影响，可以使用浅复制
# print(b, type(b))
# --------------------函数------------------------------------
# （5）不定长参数
# 定义一个函数，可以求任意数字的和
# def my_sum(a, b):
# print(a + b)
#
#
# my_sum(1, 3)
#
#
# # 定义函数可以在形参前面加上*，这样形参将会获取到所有的实参
# def my_sum2(*tuple_list):
# # print(tuple_list,type(tuple_list))#元组
# result = 0
# # 遍历元组，并累加
# for temp in tuple_list:
# result = result + temp
# print(result)
#
#
# my_sum2()
# my_sum2(1, 2, 3, 4)
#
#
# # 带星号的形参只能有一个，带星号的参数可以和其他参数配合使用
# # 可变参数可以不写在最后，但是注意带*的参数后的参数必须以关键字传递
# def my_sum3(a, *b, c):
# print(a)
# print(b)
# print(c)
#
#
# my_sum3(1, 2, 3, c=5)
#
#
# def my_sum3(*, a, b, c): # 这种还可以，挺实用
# print(a)
# print(b)
# print(c)
#
#
# my_sum3(a=4, b=6, c=5)
#
#
# def my_sum4(**a): # 星星形参，可以接受其他的关键字参数，会统一保存到字典中
# print(a, type(a))
#
#
# my_sum4(b=1, d=2)
# # **形参只能有一个，必须写在所有参数的最后
# --------------------函数------------------------------------
# （6）参数解包
# def my_fun(a, b, c):
# print(a)
# print(b)
# print(c)
#
#
# my_fun(1, 2, 3)
# t = (10, 20, 30)
# my_fun(t[0], t[1], t[2])
# # 传递实参时，也可以在序列类型的参数前添加*号，这样她会自动将序列中的元素依次传递
# # 要求序列中元素的个数必须和形参中的一致
# my_fun(*t)
# # 创建一个字典
# d = {
# "a": 100,
# "b": 2,
# "c": 3
# }
# my_fun(**d)
# --------------------函数------------------------------------
# （7）返回值
# 通过return来指定返回值
# 可以通过变量来接受返回值
# return后面跟什么，函数就返回什么，后面的对象是任意的，甚至可以为函数
# def my_sum():
# def my_print(): # 内部函数
# print("Hello")
#
# my_print()
# return my_print
#
#
# print(my_sum())
#
#
# def my_sum2():
# print("Hello")
# return ""
#
#
# # return一旦执行，函数自动结束
# my_sum2()
#
#
# def my_sum3():
# for i in range(5):
# if i == 3:
# # break
# # continue
# return ""
# print(i)
# print("循环执行完毕")
#
#
# my_sum3()
#
#
# def my_sum4():
# return 10
#
#
# # 打印的是函数对象
# print(my_sum4)
# # 打印调用的结果
# print(my_sum4())
# --------------------函数------------------------------------
# （8）文档字符串
# help()是python的内置函数
# 在定义函数时，可以编写文档字符串，就是文档说明，编写后就可以通过help函数查看
# 非常简单，直接在函数的第一行写一个字符串就是文档字符串
# help(print)
#
#
# def my_sum(a: int, b: int, c: int) -> int:
# """
# 文档说明：函数的作用是返回10
# """
# return a + b + c
#
#
# help(my_sum)
# --------------------函数------------------------------------
# （9）作用域scope
# b = 20
#
#
# def my_fun():
# a = 10 # a定义在函数内部，函数外部无法访问
# print("内部", a)
# print("内部", b)
#
#
# my_fun()
# # print("外部", a)
# print("外部", b)
# 在python有两种作用域，一种是全局作用域，一种是函数作用域
# 全局作用域在程序执行时创建，在程序执行结束时销毁
# 所有函数以外的区域都是全局作用域
# 在全局作用域中定义的变量都属于全局变量，全局变量可以在程序任意位置被访问
# 函数作用域，在函数调用时创建，在调用结束时销毁
# 函数每调用一次聚会产生一个新的函数作用域
# 在函数作用域定义的变量，都是局部变量，只能在函数内部被访问
# 当使用一个变量时会优先在当前作用域中寻找，如果有则使用，如果则去上一级作用域中寻找
# 如果依然没有，则继续去上一级中寻找，以此类推，直到找到全局作用域依然没有则会抛出异常
# def my_fun2():
# a = 30
#
# def my_fun3():
# a = 40 # 如果有重名的，
# print("fun3中,a的值为", a)
#
# my_fun3()
#
#
# my_fun2()
# a = 20
# def my_fun3():
# # 如果希望在函数内部修改全局变量，则需要使用global关键字
# # 然后再去修改a
# global a
# a = 15
# # a = 10 # 在函数中为变量赋值时，默认是为局部变量赋值
# print("函数内部", a)
#
#
# my_fun3()
# print("函数外部", a)
# --------------------函数------------------------------------
# （10）命名空间name space
# 命名空间是变量存储的位置，每一个变量都需要存储到指定的命名空间当中
# 每一个作用域都会有一个它对应的命名空间
# 全局命名空间，保存全局变量。函数命名空间用来保存函数中的变量
# 命名空间实际上就是一个字典，是一个专门用来存储变量的字典
# locals()获取当前作用域的命名空间
# 看函数调用的位置，他返回的是一个字典
# a = 20
# scope = locals()
# print(scope, type(scope))
# print(a)
# print(scope["a"])
# scope["c"] = 1000 # 向字典中添加key value就相当于添加变量，一般不会这么做
#
#
# def my_fun():
# b = 10
# fun_scope = locals() # 在函数内部调用locals()会获取到函数的命名空间
# print(fun_scope)
#
#
# my_fun()
# --------------------函数------------------------------------
# （11）递归
# 求10的阶乘
# 自己调用自己
# 无穷递归会导致内存占满退出。一般都是有条件限制的，无穷递归没有意义
# 递归是解决问题的一种方式，和循环类似
# 整体思路是将大问题-分成多个小问题，直到问题无法分解时，再解决问题
# def get_factorial(num, result=1):
# """
# 求任意数的阶乘
# :param result:
# :param num:2
# :return: result
# """
# result = result * num
# if num > 1:
# num = num - 1
# return get_factorial(num, result) # 这里有个return调用递归时，请注意，不加返回None
# else:
# return result
#
#
# print(get_factorial(10))
# 第二种方法
# 递归和循环解决问题的思路是一直的，递归编写起来难，但是方便阅读
# def get_factorial(num):
# if num == 1:
# return 1
# else:
# return num * get_factorial(num - 1)
#
#
# print(get_factorial(10))
# --------------------函数------------------------------------
# （12）高阶函数
# 在python中，函数也是一等对象，一等对象都具有如下特点：
# ①对象是在运行时创建的
# ②能赋值给变量或作为数据结构中的元素
# ③能作为参数传递
# ④能作为返回值返回
# 高阶函数
# 高阶函数至少符合以下两个特点中的一个
# ①接受一个或多个函数作为参数
# ②将函数作为返回值返回
# 定义一个函数，把指定列表中所有的偶数，保存到一个新的列表中返回
# def my_inner_fun(i):
# if i % 2 == 0:
# return True
# else:
# return False
#
#
# def my_inner_fun2(i):
# if i > 5:
# return True
# else:
# return False
#
#
# def my_fun(my_list, my_function):
# # 定义一个函数，检查数据是否是偶数
# """
# 获取指定列表中的所有偶数，并保存到新的列表中
# :param my_function:
# :param my_list:
# :return:
# """
# new_list = []
# for temp in my_list:
# if my_function(temp):
# new_list.append(temp)
# return new_list
#
#
# have_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# # 这里就可以根据用户传递函数的不同，可以实现不同的功能
# print(my_fun(have_list, my_inner_fun2))
# print(have_list)
# # 当使用函数作为参数时，实际上是将指定的代码传递给了函数
# --------------------函数------------------------------------
# （13）匿名函数
# filter()从序列中过滤出符合条件的元素，保存到一个新的序列中
# 函数：可迭代结构，需要过滤序列(可迭代结构)
# have_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
#
#
# def my_inner_fun(i):
# if i % 2 == 0:
# return True
# else:
# return False
#
#
# result = filter(my_inner_fun, have_list)
# print(list(result))
# my_inner_fun是作为参数传递进来的
# 而这个函数实际上的作用，就是作为filter()的参数，调用完毕后就没有用了
# 不上述的方式，我们推荐匿名函数，lambda函数表达式
# 语法lambda 参数列表 ：返回值
# def my_fun(a, b):
# return a + b
#
#
# print(my_fun(1, 2))
# lambda a, b: a + b
# print((lambda a, b: a + b)(10, 20))
# # 可以赋值给变量
# lambda i: i % 2 == 0
# have_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# result = filter(lambda i: i % 2 == 0, have_list)
# print(list(result))
# # 这样更利于定制函数，语法糖
# # map()可以对可迭代对象中的所有元素做指定的操作，然后将其添加到新的对象中
# result = map(lambda i: i + 1, have_list)
# print(list(result))
# 匿名一般都是作为参数使用的，其他地方一般不会使用
# --------------------函数------------------------------------
# （14）sort
# have_list = [8, 2, 1, 4, 5, 6, 7, 8, 9, 2]
# have_list = ["a", "d", "c"]
# 当传key时比较返回值，可以根据长度排序
# have_list = ["ad112", "dd", "c12121"]
# have_list.sort(key=len)
# print(have_list)
# sorted()这个函数和sort()的用法基本一致，sorted()可以对任意序列进行排序
# 并且sorted()排序不会影响原来的对象，而是返回一个新的对象
# have_list = ["2", "5", "3", 3, 8]
# have_list = "124376477"
# return_list = sorted(have_list, key=int)
# print(return_list)
# --------------------函数------------------------------------
# （15）闭包
# def my_fun():
# a = 10
#
# def inner():
# print("我是inner", a)
#
# return inner
#
#
# return_fun = my_fun()
# return_fun() # 这个函数是在内部定义的，却能在外部使用
# 所以这个函数总是能访问到fn函数内的变量
# 这种高阶函数就是闭包，这就形成了闭包，通过闭包可以创建一些只有当前函数能访问的变量
# 可以将一些私有的东西藏到闭包中
# num_list = [50, 23, 45, 10, 77]
# # sum用来求一个列表中的所有元素的和
# print(sum(num_list))
# print(sum(num_list) / len(num_list))
# def make_average():
# num_list = []
#
# def average(n):
# num_list.append(n)
# # 求平均值
# return sum(num_list) / len(num_list)
#
# return average
#
#
# return_average = make_average()
# print(return_average(10))
# print(return_average(20))
# print(return_average(30))
# 这样在外层就不能修改和看到num_list，相当于私有化了
# 形成闭包的要件
# ①有函数嵌套
# ②内部函数作为返回值返回
# ③内部函数必须要使用到外部函数的变量
# --------------------函数------------------------------------
# （16）装饰器
# def add(a, b):
# temp = a + b
# return temp
#
#
# def mul(a, b):
# return a * b
#
#
# result = add(12, 34)
# print(result)
# result = mul(12, 34)
# print(result)
#
#
# # 可以直接修改，但是会有以下问题
# # ①修改困难，不方便维护
# # ②如果函数不是你定义的，你也无法修改。会违反开闭原则
# # 程序的设计，可以扩展，但要关闭对程序的修改
# # 我们希望在不修改原函数的情况下，对函数进行扩展
# def my_fun():
# print("我是my_fun函数...")
#
#
# # 根据现有的函数创建一个新的函数
# def my_print():
# print("函数开始执行...")
# my_fun()
# print("函数执行结束...")
#
#
# my_print()
#
#
# def new_add(a, b):
# print("函数开始执行...")
# print("函数执行结束...")
# return add(a, b)
#
#
# new_result = new_add(1, 2)
# print(new_result)
# 上边的方式，可以在不修改源代码的基础上扩展了
# 但是没扩展一个都需要创建一个新函数，太麻烦了
# 为了解决这个问题，可以创建一个函数，让这个函数自动的帮我们生成函数
def add(a, b):
temp = a + b
return temp
def my_fun():
print("我是my_fun函数...")
def begin_end(need_fun):
"""
对其他函数进行扩展
:return:
"""
def new_fun(*args, **key_words_args):
print("开始执行...")
temp = need_fun(*args, **key_words_args)
print("结束执行...")
return temp
# 返回新函数
return new_fun
return_fun = begin_end(add)
print(return_fun(1, 32))
return_fun = begin_end(my_fun)
print(return_fun())
# 像begin_end我们就叫做它为装饰器
# 可以在不修改原来函数的情况下对函数进行扩展，开发时一般通过这种方式来
@begin_end
def say_hello():
print("大家好")
say_hello()
# 定义函数时，可以通过@装饰器指定装饰器，可以同时为一个函数指定多个装饰器
# 将会按照从下到上的顺序装饰
6、面向对象
# --------------------面向对象------------------------------------
# （1）概述
# 对象是内存中专门用来存储数据的一块区域
# 对象中可以存放各种数据(数字、布尔值、代码)
# 对象由三部分组成
# ①对象的id
# ②对象的类型type
# ③对象的值value
# 面向对象opp
# python是一门面向对象的编程语言
# 面向对象的语言，简单理解就是所有的操作都是通过对象来进行的
# 面向过程的语言，指将程序的逻辑分解为一个个的步骤，通过对步骤的抽象，来完成程序
# 例子：孩子上学：1.自己起床2.洗漱3.做饭4.叫孩子5.洗刷6.吃饭7.背着书包上学
# 面向过程的思想将功能分解为多个步骤，这种方式编写的代码往往只适用于一个功能
# 如果要再实现别的功能，又需要重新编写代码，可复用性比较低且难以维护
# 面向的对象编程，关注的是对象，而不是过程，一切皆对象
# 例子：1.叫孩子上学
# 面向编程的思想，所有的功能都保存到对应的对象中，要用功能，找到对象即可
# 这种读起来很清晰，并且易于维护。这种方式不太符号常规的思维，这种是领导的思维。
# 找对象、搞对象
# --------------------面向对象------------------------------------
# （2）类class
# 我们目前学习的对象都是python内置的对象
# 内置对象并不能满足所有的需求，开发中需要自定义一些对象
# 类就相当于图纸，在程序中需要根据类来创建对象
# 实例instance，如果对象通过一个类创建的，我们称这些对象是一类对象
# int() float() bool() str() list() dict() 这些都是类
# a=int(10) 等价于a=10
# 自定义的类都需要大写字母开头，大驼峰命名法
# a = int(10)
# b = str("Hello")
# print(a, b)
# 定义一个简单的类
# class Person:
# pass
#
#
# print(Person)
# # 使用类创建对象
# person = Person()
# print(person)
# person1 = Person()
# print(person1)
# person2 = Person()
# print(person2)
# print(isinstance(person, Person)) #检查是否是某个类的实例
# --------------------面向对象------------------------------------
# （3）对象的创建流程
# 类就是用来创建对象的，类也是对象
# class Person:
# pass
#
#
# print(id(Person))
# print(type(Person))
# # 内存中开辟空间-id有了-指定类型type-value
# # 现在Person就是空盒子
# # 可以向对象中添加变量，我们称为属性，对象.属性名=属性值
# person = Person()
# person.name = "孙悟空"
# print(person.name)
# # 和JS有点像
# person1 = Person()
# person1.name = "猪八戒"
# print(person1.name)
# --------------------面向对象------------------------------------
# （4）类的定义
# 数据(属性） 行为(方法)
# class Person:
# # 所定义的变量，将会称为实例的公共属性
# # 所有的实例都可以访问这些变量
# name = "默认的名字"
# age = "默认的年龄"
#
# # 也可以定义函数，类中定义的函数我们称为方法
# # 方法调用默认传一个参数，所以方法中至少定义一个形参self
# def person_print(self):
# print("默认的人类")
#
#
# person = Person()
# print(person.name)
# print(person.age)
# # 调用方法，对象.方法名
# person.person_print()
# # 在类的代码块中，我们可以定义变量和函数，变量和方法会成为实例的公共属性，所有实例都可以访问
# # 注意方法调用，默认会传递一个参数
# --------------------面向对象------------------------------------
# （5）属性和方法
# class Person:
# # 所定义的变量，将会称为实例的公共属性
# # 所有的实例都可以访问这些变量
# name = "默认的名字"
# age = "默认的年龄"
#
# # 也可以定义函数，类中定义的函数我们称为方法
# # 方法调用默认传一个参数，所以方法中至少定义一个形参self
# def person_print(self):
# print("默认的人类")
#
#
# # 任何实例都可以访问
# # 属性和方法查找流程：首先检查当前对象-然后是对应的类中，如果没有则报错
# person = Person()
# person.name = "我是小明"
# print(person.name)
# person1 = Person()
# print(person1.name)
# # 类和实例对象都可以保存属性/方法
# # 如果这个方法是共享的，则应该保存到类中
# # 如果属性、方法是某个实例独有的，则应该保存到实例中
# # 一般情况下，属性在实例中，方法在类中
# person = Person()
# person.name = "我是小明"
# del person.name
# print(person.name)
# class Person:
# # 谁调self就是谁，相当于java的this
# def say_hi(self):
# print("你好，我是" + self.name)
#
#
# person = Person()
# person.name = "猪八戒"
# person.say_hi()
# --------------------面向对象------------------------------------
# （6）类的特殊方法
# class Person:
# # 特殊方法，魔术方法，构造函数
# # 特殊方法不需要自己调用，不要尝试调用它
# # 会在特殊的时刻自动调用，会在类实例化对象的时候立刻调用
# # 作用：初始化实例对象的变量用的
# # 和java的构造函数真的是一模一样
# def __init__(self, name):
# self.name = name
#
# def say_hi(self):
# print("我是" + self.name)
#
#
# person = Person("孙悟空")
# person.say_hi()
# # 但是不添加name属性就会报错，name属性是必须的，基本name的值是不同的
# # name定义为对象后，手动添加到对象中，这种方式很容易出现错误
# # 我们希望用户在创建对象时，必须设置name，如果不设置将无法创建，java的构造函数
# # 这种方式如果你不写name，在创建对象时就会报错了，还可以一次性赋值，简化对象创建
# person1 = Person("猪八戒")
# person1.say_hi()
# person2 = Person("沙和尚")
# person2.say_hi()
# class Dog:
# def __init__(self, name, age):
# self.name = name
# self.age = age
#
# def call(self):
# print("小狗" + self.name + "叫", f"今年{self.age}岁了")
#
# def run(self):
# print("小狗" + self.name + "跑", f"今年{self.age}岁了")
#
# def bite(self):
# print("小狗" + self.name + "咬", f"今年{self.age}岁了")
#
#
# dog = Dog("小黄", 2)
# dog.call()
# dog.run()
# dog.bite()
# dog1 = Dog("小黑", 3)
# # 这种方式非常不安全，可以随意的修改，无论对错
# # 现在我们就需要一种方式，来增强安全性，私有化
# # 能不能改，我决定
# # 属性不能修改为任意的值(年龄不能是负数）
# dog1.name = "小白"
# dog1.call()
# dog1.run()
# dog1.bite()
# --------------------面向对象------------------------------------
# （7）封装
# 封装是面向对象的三大特征之一
# 作用就是隐藏一些不希望外部所访问的属性或方法
# 如何隐藏一个对象中的属性，将对象的属性名修改为一个外部不知道的名字
# 如何获取对象中的属性？提供getter和setter方法访问到属性，get_属性名
# 封装确实增加了类的定义的复杂度
# 隐藏了属性名，增了get和set，控制了属性的只读属性
# 增加了数据验证(可以在方法里写逻辑判断)，可以确保数据是正确的
# get set可以在读取和修改属性的同时做一些其他的处理
# class Dog:
# def __init__(self, name):
# self.hidden_name = name
#
# def say_hello(self):
# print(f"我是{self.hidden_name}")
#
# def get_name(self):
# print("用户读取了属性...")
# return self.hidden_name
#
# def set_name(self, name):
# self.hidden_name = name
# print("用户修改了属性...")
#
#
# dog = Dog("小黑")
# # dog.name = "阿黄"
# # dog.say_hello()
# print(dog.get_name())
# dog.set_name("小白")
# print(dog.get_name())
# --------------------面向对象------------------------------------
# （8）隐藏类中的属性
# class Rectangle:
# def __init__(self, width, height):
# self.hidden_width = width
# self.hidden_height = height
#
# def get_width(self):
# return self.hidden_width
#
# def get_height(self):
# return self.hidden_height
#
# def set_width(self, width):
# self.hidden_width = width
#
# def set_height(self, height):
# self.hidden_height = height
#
# def get_area(self):
# return self.hidden_width * self.hidden_height
#
#
# rectangle = Rectangle(2, 5)
# rectangle.set_width(20)
# print(rectangle.get_area())
# 双下划线开头的属性，是度下行的隐藏属性，只能在类的内部访问，通过对象访问不了
# 相当于java的private
# python内部其实是做了修改，__name改成了_Person__name，伪隐藏
# class Person:
# def __init__(self, name):
# self.__name = name
#
# def get_name(self):
# return self.__name
#
# def set_name(self, name):
# self.__name = name
#
#
# person = Person("陈翔")
# print(person.get_name())
# print(person._Person__name)
# print(person.__name)
# 使用__开头的属性，实际外部还是可以访问的，我们一般不用
# 我们一般会以_开头
# 相当于java的private，我们一般使用_开头的就是私有的，一般不要修改私有属性
# class Person:
# def __init__(self, name):
# self._name = name
#
# def get_name(self):
# return self._name
#
# def set_name(self, name):
# self._name = name
#
#
# person = Person("陈翔")
# print(person.get_name())
# --------------------面向对象------------------------------------
# （9）装饰器
# class Person:
# def __init__(self, name):
# self._name = name
# 用来将get方法，转换为对象的属性，添加后我们可以像调用属性一样使用方法
# 感觉没必要，用了更混乱
# @property
# def play_name(self):
# print("get方法执行了")
# return self._name
#
# @play_name.setter
# def play_name(self, name):
# self._name = name
#
#
# person = Person("唐僧")
# print(person.play_name)
# person.play_name = "悟空"
# print(person.play_name)
# --------------------面向对象------------------------------------
# （10）继承
# class Animal:
# def run(self):
# print("动物会跑")
#
# def sleep(self):
# print("动物睡觉")
# 假如狗也需要三个方法run sleep bark
# 通过继承来实现，类名后的()中就是父类；子类可以继承父类中所有的属性和方法
# 通过继承可以获取到父类的方法或属性，避免重复写代码，而且不违反OCP原则
# class Dog(Animal):
# def bark(self):
# print("小狗叫")
#
#
# class Ha(Dog):
# def foolish(self):
# print("开始犯傻")
#
#
# dog = Dog()
# dog.run()
# dog.sleep()
# dog.bark()
# print(isinstance(dog, Dog))
# print(isinstance(dog, Animal))
# ha = Ha()
# ha.run()
# ha.sleep()
# ha.bark()
# ha.foolish()
# # 在创建类时，如果省略了父类，则默认父类为object，所有的类都继承与object
# print(issubclass(Animal, object))
# --------------------面向对象------------------------------------
# （11）方法的重写
# 如果有重名则调用子类的方法，我们就叫做方法的重写override
# class Animal:
# def say(self):
# print("我是动物...")
# class Dog(Animal):
# def say(self):
# print("我是一只小狗...")
# dog=Dog()
# dog.say()
# --------------------面向对象------------------------------------
# （12）继续讲继承
# class Animal:
# def __init__(self,name):
# self.name=name
# def get_name(self):
# return self.name
# def set_name(self,name):
# self.name=name
#父类所有方法都会被子类继承，包括魔术方法
# class Dog(Animal):
# def say(self):
# print("我是一只小狗")
# dog=Dog("阿黄")
# print(dog.get_name())
# dog.set_name("小白")
# print(dog.get_name())
# class Dog(Animal):
# def __init__(self,name,age):
# #调用父类的init函数初始化name
# # Animal.__init__(self,name)
# #有没有动态的方式呢?而且super()不用传递self
# super().__init__(name)
# self.age=age
# dog=Dog("阿黄",12)
# print(f"{dog.name}, {dog.age}")
# --------------------面向对象------------------------------------
# （13）多重继承
#可以为一个类同时指定多个父类，我去和java不一样
#多重继承会使得子类有多个父类，而且会获取到所有父类的方法
#开发中没有特殊情况，不适用多重继承，多重继承会让我们的代码过于复杂
# class A(object):
# def a(self):
# print("a")
# class B(object):
# def b(self):
# print("b")
# class C(B,A):
# pass
# print(C.__bases__)
# print(B.__bases__)
# c=C()
# c.a()
# c.b()
# --------------------面向对象------------------------------------
# （14）多态
#多种形态，狗-田园犬 藏獒 哈士奇 古牧
class A:
def __init__(self,name):
self.name=name
def get_name(self):
return self.name
def set_name(self,name):
self.name=name
class B:
def __init__(self,name):
self.name=name
def get_name(self):
return self.name
def set_name(self,name):
self.name=name
a=A("陈翔")
b=B("蘑菇头")
#只要对象中有name属性，就可以作为参数传递，并没有考虑到对象的类型，类似obj这种参数这就是多态
def say(obj):
print(f"你好: {obj.get_name()}")
say(a)
say(b)
def say2(obj):
if isinstance(obj,A):
print(f"你好: {obj.get_name()}")
else:
print("参数类型不匹配...")
say2(a)
# 因为say2做了类型检查，所有传递b就不会打印
say2(b)
# 其实就是违反了多态，这样导致函数的适应性非常差
# 鸭子类型，如果一个东西走路像鸭子，叫声像鸭子，那么他就是鸭子
# 只有对象中有__len__特殊方法，就可以通过len()来获取它的长度
# 面向对象的三大特征 封装(数据安全） 继承(可扩展性) 多态(保证程序的灵活性)7、类的方法
# --------------------类的方法------------------------------------
# （1）属性方法
# class Person(object):
# #类属性，直接在类中定义的属性
# count=0
# def __init__(self):
# self.name="陈翔"
# def method(self):
# print(f"实例方法,{self}")
# @classmethod
# def class_method(cls):
# print(f"这是一个类方法,{cls}")
# @staticmethod
# def static_method():
# print(f"静态方法...")
# print(Person.count)
# person=Person()
# person.count=10
# print(Person.count)
# print(person.count)
# #类属性智能通过类来修改，无法通过实例对象修改
# Person.count=10
# person=Person()
# print(Person.count)
# print(person.count)
# print(person.name)
# #只能通过实例对象修改，无法通过类访问
# #print(Person.name)
# person.method()
# #实例方法也只能通过对象访问，直接用类不可以
# #Person.method()
# #需要类再传递self
# Person.method(Person)
# #类方法
# #@classmethod 来修饰的方法属于类方法
# #可以通过类，也可以通过实例调用，一样的
# Person.class_method()
# person.class_method()
# #静态方法，在类中使用staticmethod属于静态方法
# Person.static_method()
# person.static_method()
# #静态方法是和当前类无关的方法，它只是一个保存到当前类的函数，静态方法一般都是一些工具方法
# --------------------类的方法------------------------------------
# （2）垃圾回收
#程序运行过程中产生的垃圾，会影响程序运行的性能，所以这些垃圾必须被及时清理
#没用的东西就是垃圾
#在程序中没有被引用的对象就是垃圾
# class Person:
# def __init__(self):
# self.name="人类"
# def __del__(self):
# print(f"Person()对象被删除，{self}")
# person=Person()
# print(person.name)
# #此时没有任何对象对Person()进行引用，他就变成了垃圾，这种垃圾过多后会影响程序运行的性能
# #所以我们必须及时的进行垃圾回收，就是把垃圾对象从内存中删除
# #Python有自动的垃圾回收机制，所以我们不用手动处理垃圾回收
# #程序结束时，这些对象也会自动被删除
# person=None
# input("回车键退出...")
# --------------------类的方法------------------------------------
# （3）特殊方法/魔术方法
#特殊方法都是使用__开头__和结尾的
#特殊方法一般不需要手动调用，会在一些特殊情况下自动执行
# class Person:
# def __init__(self,name,age):
# self.name=name
# self.age=age
# #相当于java的toString呀，可以指定字符串结果
# def __str__(self):
# return f"name={self.name},age={self.age}"
# #它的作用是指定对象在 ‘交互模式’ 中直接输出的效果
# #交互模式可以直接输出
# def __repr__(self):
# return "Hello"
# #相当于java的compare
# #做大于比较时使用，改方法的返回值会作为比较的结果
# #他需要两个参数self当前对象，指向大于号左边的对象
# def __gt__(self, other):
# return self.age > other.age
# #lt < ; le <= ; eq == ; ne != ; gt > ; ge >=;
# #指定对象转换为bool值的规则
# #可以用于年龄的判断，一定情况下可以简化代码
# def __bool__(self):
# return self.age >17
# #运算的特殊方法，可以针对某个对象的属性加
# def __add__(self, other):
# return self.age+other.age
# #创建Person类的实例
# person=Person("陈翔",18)
# person1=Person("球球",19)
# #当我打印一个对象时，实际打印的是对象特殊方法__str__()的返回值
# print(person)
# print(repr(person1))
# print(person>person1)
# print(bool(person))
# print(person+person1)
# --------------------类的方法------------------------------------
# （4）模块化概述
#模块 module 模块化
#模块化指将完整的程序分解为一个个小的模块，通过模块组合，搭建出一个完整的程序
#不用模块化，将所有的代码保存到一个文件中
#采用模块化，将程序分别编写到多个文件中
#各有各的好处
# 模块化就是方便开发，方便维护，可以复用
#一个Python文件就是一个模块
#引入和使用外部模块，模块名就是文件名不带py
#引入一次即可，多次引用也没有用
#引入模块的第二种方式
# import my_module
#以别名的方式引入
# import my_module as test
#调用模块里的方法
#一般都写到程序的开头
# my_module.my_function()
#name属性为__main__是主模块，一个程序中只有一个主模块
# print(__name__)
#模块的使用
# print(my_module.a)
# person=my_module.Person()
# print(person.name)
#也可以引入模块中的部分值 语法 from 模块名 import 变量,变量...
#from my_module import Person
#from my_module import my_function
#from my_module import my_function,Person
#from my_module import * ;引入到模块中的所有内容，不建议使用
#也可以为引入的变量使用别名
#添加_下划线的变量只能在模块中访问，from my_module import * 这种方式的就不能访问
#建议统一使用import my_module引用
#if __name__ == "__main__": 使得模块里的测试方法，在引用时不会被执行
# --------------------类的方法------------------------------------
# （5）包
#和java的package一样
#包也是一个模块，是一个比较强大的模块
#当模块中的代码过多，或一个模块需要分解为多个模块时，就需要用到包
#普通的文件是py文件，而包是一个文件夹
#包中必须要有__init_.py文件，其中可以包含模块的信息
# import my_package
# from my_package import package_a
# my_package.my_function()
# print(package_a.c)
#使用模块或包时，需要先将他们的代码转换为机器码—>计算机执行
#python在编译一次后，将代码保存到一个缓存文件中，这样加载这个模块/包是，就可以
#直接从缓存中取
# --------------------类的方法------------------------------------
# （6）Python标准库
#开箱即用，为了实现这个，Python为我们提供了模块的标准库
#在这个标准库中，有很多强大的模块我们可以直接使用，并且随着Python的安装而安装
#sys模块，体用了一些变量和函数值，可以获取到Python解析器的信息
#或者可以通过函数来操作Python解析器
import sys
print(sys)
#sys.argv
#在控制台可以用到,SpeechIO的demo示例也用到了
for temp in sys.argv:
print(temp)
print(sys.modules)
import pprint
#漂亮的打印
pprint.pprint(sys.modules)
#类似环境变量，会到以下路径寻找模块或库
print(sys.path)
pprint.pprint(sys.path)
# sys.platform
#python当前运行的平台
print(sys.platform)
#sys.exit() 用来退出程序
# sys.exit("程序异常终止...")
print("Hello")
#os模块让我们可以对操作系统进行访问
import os
#os.environ
pprint.pprint(os.environ['path'])
#相当于在dos界面执行命令
os.system("ping baidu.com")
8、异常与文件
# --------------------异常与文件------------------------------------
# （1）异常
# 程序在运行过程中，不可避免的会出现一些错误，比如没有赋值的变量，/0，使用了不存在的索引
# print(10 / 0)
# 异常会导致程序终止，而且以后的代码都不会执行
# 异常的处理
# try:
# # 有可能出现错误的代码
# print(10 / 2)
# except:
# # 出错以后的处理方式
# print("发生异常")
# else:
# print("程序正常执行...")
# finally:
# print("最终执行的代码...")
# print("最后执行的代码...")
# --------------------异常与文件------------------------------------
# （2）异常传播
# def my_function():
# print(10 / 0)
#
#
# # 如果不对异常进行处理，异常会向上传播
# # 如果写了try expect语句则不会传播
# my_function()
# 传递到全局作用域，如果依然没有处理，则程序终止，并且显示异常信息
# 异常信息是保存到异常对象中的，异常传播时实际就是异常对象抛给了调用处
# ZeroDivisionError表示除0的异常
# NameError专门用来处理变量错误的异常
# 在Python中为我们提供了多个异常对象...
# --------------------异常与文件------------------------------------
# （3）异常对象
# print("异常出现前")
# try:
# # print(c)
# print(10 / 0)
# # except NameError:
# # #如果except后不跟任何内容，会捕获到所有的异常
# # #可以跟异常类型，此时只会捕获改类型的异常
# # print("NameError异常处理代码...")
# # except ZeroDivisionError:
# # #如果except后不跟任何内容，会捕获到所有的异常
# # #可以跟异常类型，此时只会捕获改类型的异常
# # print("ZeroDivisionError异常处理代码...")
# except Exception as e:
# #Exception是所有异常类的父类
# print(f"捕获到的异常...{e}")
# finally:
# print("最终执行的语句...")
# print("异常出现后")
# --------------------异常与文件------------------------------------
# （4）抛异常和自定义异常对象
# 抛出异常
# class MyError(Exception):
# pass
# def add(a,b):
# if a<0 or b<0:
# #raise可以抛出异常
# #抛出异常的目的是告诉调用者调用时初夏你问题，希望你自己处理下
# # raise Exception("两个参数中不能有负数...")
# raise MyError("自定义异常...")
# r=a+b
# return r
# print(add(-1,3))
# --------------------异常与文件------------------------------------
# （5）文件的打开
# Python程序对计算机中文件进行增删改查
# Input Output
# 打开文件-读文件/写文件&保存-关闭文件
# 打开文件，用copy path写几遍就知道路径怎么写了
# my_file=open("Hello.txt")
# print(my_file)
# --------------------异常与文件------------------------------------
# （6）文件的关闭
# my_file=open("Hello.txt")
# #读取文件的内容
# my_file_content=my_file.read()
# print(my_file_content)
# #关闭文件，特别是在web服务器中，多次打开不关闭很影响性能
# my_file.close()
# with...as语句
# with open("Hello.txt") as my_file:
# print(my_file.read())
# try:
# with open("Hello1.txt") as my_file:
# print(my_file.read())
# except Exception as e:
# print(f"文件不存在{e}")
# --------------------异常与文件------------------------------------
# （7）文件的读取
# try:
# with open("Hello.txt",encoding="UTF-8") as my_file:
# #read会全部读进来，如果读取文件较大，会一次性将文件的内容加载到内存中，很容易让内存
# #溢出，对于比较大的文件不要直接调用read()，read可以接受一个size作为参数，改参数
# #可以指定读取字符的数量，可以为size指定值，每一次读取都是从上次读取到的位置开始读取
# #如果字符数量小于size，则会读取剩余所有的。如果读取到文件的最后则会返回“”空串
# # print(my_file.read(size))
# #下面这种就是读取大文件的方式
# chunk=6
# while True:
# index=my_file.read(chunk)
# if not index:
# #内容读取完毕，break退出
# break
# print(index,end="")
# except Exception as e:
# print(f"发生读取错误{e}")
# #open打开文件时默认是以文本形式打开的，但是open默认的编码为None，默认使用gbk
# #想打开中文必须指定文件编码
# --------------------异常与文件------------------------------------
# （8）文件的读取其他方法
# with open("Hello.txt",encoding="UTF-8") as my_file:
# # print(my_file.readline(),end="")
# # print(my_file.readline(),end="")
# # print(my_file.readlines())
# # print(my_file.readlines()[0])
# for temp in my_file:
# print(temp,end="")
# --------------------异常与文件------------------------------------
# （9）文件的写入
# 使用open打开文件时，必须要指定打开文件所需要做的操作读写追加
# 如果不指定默认是读取文件，没有写的权限
# w表示可以读可以写，w文件不存在则创建文件，如果文件存在则会删除原有文件的内容
# write可以分多次向文件中写入内容
# a 表示追加内容，a如果文件不存在则创建文件，存在则追加内容
# r+代表可读可写，但是不会自己创建文件
# w+代表写和读
# a+代表追加和读
# x用来新建文件，不存在创建，存在则报错
# with open("Hello.txt",mode="a",encoding="UTF-8") as my_file:
# #write()向文件中写入内容
# my_file.write("Hello 陈翔
")
# my_file.write("Hello 蘑菇头
")
# t读取文本文件 r=rt w=wt a=at t是默认可见的
# b读取二进制文件,rb 而且不能指定encoding参数
# with open("1.jpg",mode="rb") as my_file:
# # print(my_file.read(100))
# new_file_name="2.jpg"
# with open(new_file_name,"wb") as new_file:
# chunk=1024*100
# while True:
# #从老文件读数据
# content=my_file.read(chunk)
# #将读取的数据写入到新对象
# new_file.write(content)
# #内容读取完毕终止循环
# if not content:
# break
# --------------------异常与文件------------------------------------
# （10）seek()和tell()
# with open("Hello.txt","rb") as my_file:
# print(my_file.read(20))
# #tell() 方法用来查看当前读取到的位置
# print(f"当前读取的位置{my_file.tell()}")
# #seek()修改当前的读取位置
# my_file.seek(55)
# print(f"当前读取的位置{my_file.tell()}")
# --------------------异常与文件------------------------------------
# （11）文件的其他操作
import os
# 获取到该路径下的目录结构，默认为当前目录
r = os.listdir()
print(r)
# 当前所在目录
r = os.getcwd()
print(r)
# 切换目录
os.chdir("..")
r = os.getcwd()
print(r)
# os.mkdir() 创建目录
# os.rmdir() 删除目录
# os.remove("文件") 删除文件
#os.rename("","") 重命名，还有移动的功能
1675
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
