ξ1 Python 缩进
同一代码块中使用相同数量的空格
ξ2 Python 注释
单行注释以#开头
多行注释"""注释内容""" 或 '''注释内容'''
ξ3 Python 变量
变量是存放数据值的容器。与其他编程语言不同，Python 没有声明变量的命令。首次为其赋值时，才会创建变量。
变量可以在设置后更改
字符串变量可以使用单引号或双引号声明str="Hello"或str='World'
Python 变量命名规则：
变量名必须以字母或下划线字符开头 #注意字母区分大小写
变量名称不能以数字开头
变量名只能包含字母数字字符和下划线（A-z、0-9 和 _）
一行为多个变量赋值 x,y,z = "red","blue","green"
一行为多个变量赋相同的值 x = y = z = "red"
结合文本和变量输出用 + 连接 print("I am " + name)
+ 作用 1、结合文本和变量 2、文本变量和另一个文本变量连接 3、数学运算符
不同类型变量相加会出错 x="hello" y=10 print(x+y)改为print(x+str(y))
在函数外部创建的变量称为全局变量。
全局变量可以被函数内部和外部的每个人使用。
如果在函数内部创建具有相同名称的变量，则该变量将是局部变量，并且只能在函数内部使用，函数内使用此变量自动屏蔽函数外同名变量。具有相同名称的全局变量将保留原样，并拥有原始值。
函数内部变量想要变成全局变量，变量名前加关键字 global
ξ4 Python 类型
文本类型： str
数值类型： int, float, complex #complex 是复数类型
序列类型： list, tuple, range #列表， 元组，
映射类型： dict
集合类型： set, frozenset
布尔类型： bool
二进制类型： bytes, bytearray, memoryview
指定变量的数据类型 data = 类型名(数据) #这里是圆括号
ξ5 Python 数字类型
python数字有三种类型int float complex
可以使用int()、float() 和 complex() 方法从一种类型转换为另一种类型
如 data = 2 x = float(data)
Python没有 random() 函数来创建随机数，但 Python 有一个名为 random 的内置模块
召唤0~9之间的随机数
import random
print(random.randrange(1,10)) #(1,10)包括左不包括右
ξ6 Python 字符串
python 中的字符串字面量由单引号或双引号括起。'hello' 等同于 "hello"
利用 = ，可以把字符串赋值给变量 a = "Hello"
利用三引号将超过一行的字符串赋给变量x = """字符串"""或x = '''字符串'''
Python 中的字符串是表示 unicode 字符的字节数组。可用方括号可用于访问字符串的元素。
a = "Hello, World!"
x = y= z =2022
print(a[2]) #方括号可用于访问字符串的元素。
print(a[2:5]) #获取从位置 2 到位置 5（不包括）的字符
print(a[-3:-1]) #获取从位置 -3 到位置 -1（不包括）的字符
print(len(a)) #获取a的长度
print(a.strip()) #strip() 方法删除开头和结尾的空白字符
print(a.lower()) # returns hello, world!
print(a.upper()) # returns HELLO, WORLD!
print(a.replace("World", "Kitty")) # returns Hello, Kitty!
print(a.split(",")) # returns ['Hello', ' World!']
print("llo" in a) # returns Ture
print("llo" not in a) # returns False
# 错误写法print("Hello, World" + x) #字符串和数字不能直接相连
print("Hello, World " + str(x))
print("Hello, World {}".format(x))#format() #方法接受传递的参数，格式化它们，并将它们放在占位符 {} 所在的字符串中
print("Hello, World {1} {2} {0}".format(x,y,z)) #使用索引号来确保参数被放在正确的占位符中
所有字符串方法都返回新值。它们不会更改原始字符串
ξ7 Python 布尔
计算 Python 中的任何表达式，并获得两个答案之一，即 True 或 False。
bool() 函数可让您评估任何值，并为您返回 True 或 False。
()、[]、{}、""、数字 0 和值 None 评估为 False
isinstance() 函数，该函数可用于确定对象是否具有某种数据类型 print(isinstance(x, int))
Python 运算符
算术运算符 + - * / % ** //(取整除)
赋值运算符 = += -= *= /= %= **= //= &= |= ^= >>= <<=
比较运算符 == != > < >= <=
逻辑运算符 and or not
身份运算符(身份运算符用于比较对象，不是比较它们是否相等)
x = 1
y = x
print(x is y) #returns Ture
print(x is not y) #returns False
成员运算符 in not in
位运算符 & | ^ ~ << >>
列表 List
列表是一个有序且可更改的集合。在 Python 中，列表用方括号编写
colorlist = ["red", "green", "blue","yellow"]
colorlist[0] = "white"
print(colorlist.count('blue')) #返回列表中指定值出现的次数。
print(colorlist.index('blue')) #返回列表中指定值第一次出现的索引。
print(colorlist[1]) #根据索引访问
print(colorlist[-1]) #根据负索引访问
print(colorlist[1:3]) #切片截取
for x in colorlist: #遍历列表
print(x)
print("blue" in colorlist) #验证项目是否存在
print(len(colorlist)) #输出项目个数
#添加元素
colorlist.append("orange") #在列表后面直接添加项目
colorlist.insert(1,'black') #根据索引值添加项目
#删除列表 通过键入 list2 = list1 来复制列表,list2 将只是对 list1 的引用，list1 中所做的更改也将自动在 list2 中进行。
colorlist.remove('blue') #根据内容删除项目
colorlist.pop() #根据索引删除项目(无索引时，默认-1)
del colorlist[0] #根据索引删除项目
del colorlist #删除列表,colorlist不存在
# colorlist.clear() #删除列表所有项目，colorlist存在，只是没项目
#制作副本
mylist = colorlist.copy() #复制列表
mylist = list(colorlist) #内建list()方法
print(mylist)
#合并两个列表
list1 = colorlist + mylist # + 连接
for x in mylist:
colorlist.append(x) # 利用 append(名字) 逐个添加
colorlist.extend(mylist) #利用 extend(名字) 全部添加到末尾
list2 = list(("a","b","c","d")) #list() 构造函数创建一个新列表。注意双括号！
list1.sort() #对列表进行排序,按照首字母
list1.reverse() #颠倒列表
print(colorlist.index("blue")) #查找指定值的第一个项目索引
元组 Tuple
元组是有序且不可更改的集合。在 Python 中，元组是用圆括号编写的。
colortuple = ('red','blue','green','white')
'''
错误，元素不能改变 colortuple[1] = 'yellow' 错误，元素不能改变
创建元组后，不赋新元组，一直不变。无法更改其值,也不能添加项目，顺序也不能改。
但是有一种解决方法。您可以将元组转换为列表，更改列表，然后将列表转换回元组。
mylist = list(colortuple);mylist[0] = "white";colortuple = tuple(mylist);print(colortuple)
'''
print(colortuple.count('blue')) #返回元组中指定值出现的次数。
print(colortuple.index("blue")) #查找指定值的第一个项目索引
print(colortuple[1]) #根据索引访问
print(colortuple[-1]) #根据负索引访问
print(colortuple[1:3]) #切片截取
for x in colortuple: #遍历列表
print(x)
print("blue" in colortuple) #验证项目是否存在
print(len(colortuple)) #输出项目个数
创建仅包含一个项目的元组，必须在该项目后添加一个逗号，否则 Python 无法将变量识别为元组。colortuple = ('red',)
del colortuple #元组是不可更改的，但可以完全删除元组
tuple3 = tuple1 + tuple2 #元组可以用+连接形成新元组
tuple1 = tuple(('red','blue','green','white')) #可以使用 tuple() 构造函数来创建元组。注意双括号！
集合 set
集合是无序和无索引的集合。在 Python 中，集合用花括号编写。
colorset = {'red','blue','green','white'}
print(colorset) #每次显示出来顺序不一样
for x in colorset:
print(x) #无法通过引用索引来访问 set 中的项目，只能for 循环遍历 set 项目
print('blue' in colorset) #使用 in 关键字查询集合中是否存在指定值
集合一旦创建，您就无法更改项目，但是可以添加新项目。
colorset.add('yellow') #添加一个项目
colorset.update(("orange", "mango", "grapes")) #添加多个项
#删除元素
colorset.remove('red') #删除元素不存在将引发错误
colorset.discard('red') #删除元素不存在不会引发错误
x = colorset.pop() #返回被删除值
colorset.clear() #删除集合所有项目，colorset存在，只是没项目
del colorset #彻底删除集合，del是关键字不用加 .
#合并两个集合
set3 = set1.union(set2) #union()方法返回一个新集合
set1.update(set2) #update() 方法将 set2 中的项目插入 set1 中
union() 和 update() 都将排除任何重复项。
set1 = set(('red', 'green', 'black')) #可以使用 set() 构造函数来创建集合
python 字典
字典是一个无序、可变和有索引的集合。在 Python 中，字典用花括号编写，拥有键和值。
thisdict = {
"brand": "Porsche",
"model": "911",
"year": 1963
}
x = thisdict['model'] #通过索引获取项目值
x = thisdict.get('model') #通过 get() 方法获取项目值
thisdict["year"] = 2022 #通过索引更改项目值
for x in thisdict:
print(x) #打印键名
print(thisdict[x]) #打印值
for x in thisdict.values():
print(x) #使用 values() 函数返回字典的值
for x, y in thisdict.items():
print(x, y) #使用 items() 函数遍历键和值
if "model" in thisdict:
print("Yes“) #确定字典中是否存在指定的键
print(len(thisdict)) #打印字典中的项目数
thisdict["color"] = "red" #添加项目
thisdict.pop('model') #通过索引删除项目值
thisdict.popitem() #删除最后一个项目
del thisdict['model'] #通过索引删除项目值
del thisdict #删除整个字典
thisdict.clear() #删除字典所有项目，thisdict存在，只是没项目
mydict = thisdict.copy() #使用 copy() 方法来复制字典
mydict = dict(thisdict) #使用 dict() 方法创建字典的副本
词典也可以包含许多词典，这被称为嵌套词典。
thisdict = dict(brand="Porsche", model="911", year=1963)
# 请注意，关键字不是字符串字面量
# 请注意，使用了等号而不是冒号来赋值
列表，字典，元组都有索引，都可以通过索引访问，遍历。但是元组不能更改
列表，字典，集合都可改变，但是集合无序，无索引
列表和字典最像
选择语句
形式1：
if 表达式 ：
语句
形式2：
if 表达式 ：
语句1
else:
语句2
形式3：
if 表达式 ：
语句1
elif:
语句2
else:
语句3
形式4：
满足语句1 if 表达式 else 不满足语句2
if 语句不能为空,可用pass填充。
循环语句
形式1：
while 表达式 ：
语句
形式2：
while 表达式 ：
语句1
else:
语句2 #不成立时运行代码块 else 一次
形式3：
for x in 序列名字： #列表，元组，字典，集合或字符串
语句
形式4：
for x in 序列名字：
语句1
else:
语句2 #不成立时运行代码块 else 一次
break #即使 while 条件为真，也可以停止循环
continue #停止一次循环
range() 函数返回一个数字序列，默认情况下从 0 开始，并递增 1（默认地），并以指定的数字结束。range(start,end,step)
for 语句不能为空，可用pass填充。
Python 函数
在 Python 中，使用 def 关键字定义函数
def fun(参数): #参数可以是1个，多个或序列
程序块
fun() #调用函数
def fun(country = 'China'): #设置默认参数
print("I am from " + country)
可以设置 return 语句返回值
可以使用 key = value 语法发送参数，参数的顺序无关紧要。
def my_function(child3, child2, child1):
print("The youngest child is " + child3)
my_function(child1 = "Phoebe", child2 = "Jennifer", child3 = "Rory")
如果您不知道将传递给您的函数多少个参数，请在函数定义的参数名称前添加 *。
这样，函数将接收一个参数元组，并可以相应地访问各项：
def my_function(*kids):
print("The youngest child is " + kids[2])
my_function("Phoebe", "Jennifer", "Rory")
Python Lambda
lambda 函数是一种小的匿名函数。
lambda 函数可接受任意数量的参数，但只能有一个表达式
lambda 变量: 表达式
x = lambda a, b, c : a + b + c #相当于 x = x(a,b,c)
print(x(1, 2, 3))
def myfunc(n):
return lambda a : a * n
x = myfunc(3) #x = lambda a : a * 3
print(x(11))
Python 数组
Python中数组用 列表 替代
列表的方法
append() extend() insert() count() index() copy() clear() pop() remove() reverse() sort()
类和对象
Python 中的几乎所有东西都是对象，拥有属性和方法。
如需创建类，请使用 class 关键字：
class 名字：
属性和方法
创建对象：
x = 类名
所有类都有一个名为 __init__() 的函数，每次使用类创建新对象时，都会自动调用 __init__() 函数。
使用 __init__()函数将值赋给对象属性，或者在创建对象时需要执行的其他操作。
class person:
def __init__(self,name,age): #init 前后两个 _
self.name = name
self.age = age
def introduce(self): #方法
print('My name is ' + self.name)
p1 = person('Bill', 22)
p1.name = 'ikun' #修改某一属性
#del p1.name #删除对象某一属性
#del p1 #删除对象
print(p1.name, p1.age)
p1.introduce()
1、self 参数是对类的当前实例的引用，用于访问属于该类的变量。
2、它不必被命名为 self，您可以随意调用它。
3、但它必须是类中任意函数的第一个参数
继承
一类继承另一个类的所有方法和属性的类。
父类是继承的类，也称为基类。
子类是从另一个类继承的类，也称为派生类。
#创建父类
class person:
def __init__(self,name,age): #init 前后两个 _
self.name = name
self.age = age
def introduce(self): #方法
print('My name is ' + self.name)
#创建子类 创建子类时将父类作为参数发送
#class 子名(父名)：
# 添加新属性和方法
class student(person):
def __init__(self,name,age,ID):
person.__init__(self, name ,age)
#或者super().person.__init__(name ,age)
self.ID = ID
p1 = student('Bill', 22, '1810600277')
print(p1.name, p1.age, p1.ID)
p1.introduce()
！！！注意：子的 __init__() 函数会覆盖对父的 __init__() 函数的继承。
如需保持父的 __init__() 函数的继承，添加对父的 __init__() 函数的调用。
方法1、 父名.__init__(self, 参数)
方法2、 super().__init__(仅参数)
迭代
在 Python 中，迭代器是实现迭代器协议的对象，它包含方法 iter() 和 next()。
可迭代对象有列表，元组，字典，集合，字符串，range()
corlorlist = ['red','black', 'white']
x = iter(corlorlist)
print(next(x))
print(next(x))
print(next(x))
遍历迭代器
for x in 'ikun':
print(x)
模块 Module
模块是包含一组函数的文件
一、创建模块
如需创建模块，只需将所需代码保存在文件扩展名为 .py 的文件中
文件名.py
二、使用模块
1、用 import 语句来使用我们刚刚创建的模块
import 文件名
文件名.函数名()
2、模块可以包含已经描述的函数，但也可以包含各种类型的变量（数组、字典、对象等）
x = 模块名.变量
3、导入模块时使用 as 关键字创建别名
import 文件名 as 别名
三、内建模块
import platform
x = platform.system()
x = dir(platform) #列出platform中所有函数名
四、使用 from 关键字选择仅从模块导入部件
from 文件名 import 部件名
部件是 函数 或者 变量 直接运用，不用在加模块名了
日期
一、Python 中的日期不是其自身的数据类型，但是我们可以导入名为 datetime 的模块，把日期视作日期对象进行处理。
import datatime
x = datatime.datatime.now()
#第一个datatime是模块名，第二个datatime是类名，now()是类的方法
创建日期对象
x = datatime.datatime(2022,6,22)
二、strftime() 方法
datetime 对象拥有把日期对象格式化为可读字符串的方法。
该方法称为 strftime()，并使用一个 format 参数来指定返回字符串的格式
print(x.strftime("format"))
format可以是%Y %B %d %A %H %M %S 年月日周时(24)分秒
输入与输出
x = input() #input()永远输入的都是字符串
格式化输入输出
print("I am {}, {} years old.".format(name,age))
保留两位小数{：.2}
print("The pen is {:.2} dollors".format(price))
根据索引填
print("I want {0} pieces of item number {1} for {2:.2f} dollars.".format(quantity, itemno, price))
多态
多态就是多种形态，同一种行为对不同子类有不同的行为表现
两个前提1、继承父类：必须发生在父类和子类之间 2、重写父类方法
class Animal:
def say_who (self)
pass
class Duck(Animal):
def say_who(self)
pass
class Dog(Animal):
def say_who(self)
pass
优点：增加程序灵活性，扩展性
类属性与实例属性
class Student:
name = 'ikun' #类属性
def __init__(self,age):
self.age = age #实例属性
lm = Student(18)
print(lm.name) #通过实例对象访问类属性
print(lm.age) #通过实例对象访问实例属性
print(Student.name) #通过类对象访问类属性
#错误print(Student.age) #通过类对象访问实例属性
小结
类属性可以由类对象和实例对象访问
实例属性只能由实例对象访问
通过实例对象无法修改类属性
通过类对象可以修改类属性 Student.name = 'cxk'
类属性所有权力属于类对象
类方法与静态方法
class Person:
name = 'ikun'
age = 22
@classmethon #说明下面方法是类方法 @classmethon修饰
def say_who (self)
pass
@staticmethod #说明下面方法是静态方法 @staticmethon修饰
def say_age (self)
pass
小结
类方法可以由类对象和实例对象访问
静态方法也可以由类对象和实例对象访问
为什么要使用静态方法呢
由于静态方法主要来存放逻辑性的代码，本身和类以及实例对象没有交互，也就是说，在静态方法中，不会涉及到类中方法和属性的操作
类方法、实例方法、静态方法对比
1．类方法的第一个参数是类对象cls，通过cls引用的类对象的属性和方法（def 方法名 (cls):）
2．实例方法的第一个参数是实例对象self，通过self引用的可能是类属性、也有可能是实例属性这个需要具体分析，不过在存在相同名称的类属性和实例属性的情况下，实例属性优先级更高。（def 方法名 (self):）
3．静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必须通过类对象来引用。（通过类对象去引用 类名.类属性）
私有化属性
语法：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。
示例： class Person:
__name = 'ikun' #定义了一个私有化属性
def __init__ (self):
self.__age = 22
p1 = Person()
print(p1.__age) ##报错，访问不了
print(Person.__name) ##报错，访问不了
使用场景： 1、不能类外调用
2、不能随意更改
3、不能被子类继承
私有化成员可以在类的内部修改（只能通过类的方法修改访问）
私有化方法
语法：两个下划线开头，声明该方法为私有，不能在类的外部被使用。
只能内部调用。子类不能继承，类外不能调用。
__xxx__ 前后两条横线，一般是Python自有的
文件
open('文件路径','打开方式')
打开方式'r',文件只读 #只读
打开方式'w',文件存在时覆盖，没有重建 #重写
打开方式'a',文件存在时从末尾开始写，没有重建 #追加
fp=open('C:计算机学习python项目cf.doc','w')
fp.write('kunkunn')
fp.close()
fp=open('C:计算机学习python项目cf.doc','r')
print(fp.read())
num=fp.read(2) #ku
print(num) #n kun
fp.close()
with open('文件路径','方式') as 名字：
print(f.操作())
f.write("")
#优点：自动释放关联对象
#小结
#文件读写的几种操作方式
# read r r+ rb rb+
# r r+ 只读 使用普通读取场景
# rb rb+适用于文件 图片 视频 音频 这样文件读取
# write ww+ wb+ wb a ab
#w wb+ w+每次都会去创建文件
#二进制读写的时候要注意编码问题默认情况下我们写入文件的编码是gbk
#a ab a+在原有的文件的基础之后去【文件指针的末尾】去追加，并不会每次的都去创建一个新的文件
adr=fp.tell() #返回光标的位置
print(fp.truncate(num)) #截取操作,保留前num个字符
f.seek(偏移量,位置) #控制光标移动
偏移量,负数往左偏移，正数往右偏移
位置，0从开头，1当前位置，2末尾
模块
导入模块首先在当前目录下搜索
如果目录没有，到环境变量中找，可以用sys模块中的path变量查看所有位置
如果没有，搜索默认路径，linix系统，默认路径一般为/user/local/lib/python/
