独自一人和蟒蛇大战三天三夜后得到了这个

学Python，爽！
本蒟蒻初次接触python，如有错误欢迎指正~

一、

（一）输入输出

1.输入

变量 = input()

变量 = input("...")	#括号中的内容会事先输出，然后再从控制台输入内容

2.输出

print()

输出格式

eg:
print("1+1的结果是：%d" %(1+1))

print(f"1+1的结果是：{1+1}")

（二）导包

为了使用其他包(或模块)中的方法，需进行导包操作
使用import关键字

import 包名

（三）变量

1.变量是什么

变量是在程序运行时记录数据用的，用于储存计算结果或表示值的抽象概念

2.定义格式

变量名称 = 变量值

eg: a = 1

（四）数据类型

1.常见数据类型

• 数字：整数（int）、浮点数（float）、复数（complex）
• 布尔（bool）
• 字符串（String） #Python中被 " " 或 ’ ’ 包围起来的都是字符串
• 列表（List）
• 元组（Tuple）
• 集合（Set）
• 字典（Dictionary）

2.判断数据类型

type( )语句

eg:
print(type(123))		#运行结果<class 'int'>
print(type('abc'))	#运行结果<class 'str'>

3.数据类型转换

int(x)

float(x)

str(x)

（五）字面量

在代码中可以被写下来的固定值
可被写下的值为以上几种常见数据类型

eg：
123
1145.14
abc

（六）标识符

1.作用

   作为变量、方法、类 的名字

2.规则

• 内容限定

只可使用英文、中文、数字、下划线 _

• 大小写敏感

eg: abc 与 ABC不同

• 不能使用关键字

eg: if、for、else等等

（七）运算符

1.算术运算符

• • 加
• • 减
• • 乘
• / 除
• // 取整除
• % 取余数
• ** 指数

2.赋值运算符

• = 赋值运算符 将等号右边的值赋值给左边 eg: a=1
• += 加法赋值运算符 a+=b 等效于 a=a+b
• -= 减法赋值运算符 a-=b 等效于 a=a-b
• = 乘法赋值运算符 a=b 等效于 a=a*b
• /= 除法赋值运算符 a/=b 等效于 a=a/b
• %= 取余赋值运算符 a%=b 等效于 a=a%b
• = 幂赋值运算符 a=b 等效于 a=a**b
• //= 取整除赋值运算符 a//=b 等效于 a=a//b

二、

（一）条件判断语句

1.if语句

if 判断条件:
  若条件成立将要执行的代码

if a>0:
  print("条件成立了")

2.if-else语句

if 判断条件:
  若条件成立将要执行的代码
else:
  若条件不成立将要执行的代码

if a>0:
  print("条件成立了")
else:
  print("条件不成立")

3.if-elif-else

if 判断条件1:
  若条件成立将要执行的代码
elif 判断条件2:
  若条件成立将要执行的代码
elif 判断条件3:
  若条件成立将要执行的代码
...
else:
  若条件不成立将要执行的代码

if a<10:
  print("条件成立了")
elif a<20:
  print("条件成立了")
elif a<30:
  print("条件成立了")
else:
  print("条件不成立")

（二）循环语句

1.while

while 条件:
    条件满足将要执行的代码

while a<100:
  print("holle world")

2.for

for 临时变量 in 处理数据集:
    条件满足将要执行的代码

word = "abcd"		#先定义数据集
for x in word:
  ptint(x)

3.range语句

一、range(num)

从0开始到num的数字序列 (不包含num)
eg: range(10) 获得的数字序列为[0，1，2，3，4，5，6，7，8，9]

二、range(num1，num2)

从num1开始到num2的数字序列 (不包含num2)
eg: range(1,5) 获得的数字序列为[1，2，3，4]

三、range(num1，num2,step)

从num1开始到num2，步长为step的数字序列 (不包含num2，step默认长度为1)
eg: range(1,10,2) 获得的数字序列为[1，3，5，7，9]

4.break continue

break：退出循环
continue：结束本轮循环，进入下轮循环

三、

（一）函数

1.定义语法

def 函数名(传入参数):		#有些函数可为空参
    函数体
    return 返回值

2.变量

一、局部变量

定义在函数体内部的变量，只能在该函数体中使用

二、全局变量

定义在函数体外部的变量，在所有函数体中都能使用

3.返回值

通过return关键字将函数运算结果返回函数调用者

4.嵌套调用

在函数中调用另一个函数(在函数中被调用的函数要提前被定义好)

def f1():
  print("我是f1")

def f2():
  f1()
  print("我是f2")

5.说明语法

用于理解函数作用的解释说明

def f(x,y):
  """
  函数说明
  :param x: 形参x的说明
  :param y: 形参y的说明
  :return: 返回值的说明
  """

  函数体
  ...
  return 返回值

6.lambda匿名函数

lambda函数定义无名称的匿名函数，可临时使用一次

lambda 传入参数:函数体(一行代码)

eg:
def f1(f):						#f为一个函数
    result = f(1,2)
    print(result)
    
f1(lambda x,y: x+y)    

四、

（一）数据容器

1.列表（元素有序且可重复）

一、定义

列表名称 = [元素1,元素2,元素3,元素4,元素5,...]

列表名称 = []
或
列表名称 = list()

列表[索引] = 值

eg:
list = [1,2,3,4,5]

print(list[0])  # 1
print(list[1])  # 2
print(list[2])  # 3
print(list[3])  # 4
print(list[4])  # 5

二、使用操作

列表.index(元素)

eg:
list = ['a','b','c']

print(list.index('a'))  # 0

len(列表)

eg:
list = ['a','b','c']
print(len(list))					# 3

列表.count(元素)

eg:
list = ['a','a','c']
print(list.count('a'))			# 2

列表[索引] = 值

eg:
list = ['a','b','c']			#将列表中的'a'修改为'd'
list[0] = 'd'    					#['d','b','c']

列表.insert(索引,元素)		#在索引对应元素后面插入元素

eg:
list = ['a','b','c']			#在列表中的'a'后面添加'd'
list.insert(0,'d')				#['a','d','b','c']

列表.append(元素)		#将元素(单个)追加到列表末尾

eg:
list = ['a','b','c']			#在列表末尾添加'd'
list.append('d')					#['a','b','c','d']


列表.extend(元素)		#将元素(多个)追加到列表末尾

eg:
list = ['a','b','c']			#在列表末尾添加多个元素
list.extend(['d','e','f'])					#['a','b','c','d','e','f']

del 列表[下标]、列表.pop(下标)、列表.remove(元素)

eg:
list = ['a','b','c','d']
del list[0]							#['b','c','d']
list.pop(1)							#['c','d']
list.remove('c')				#['d']

列表.clear()

list = [1,2,3,4,5]

index = 0
while index < len(列表):
    print(list[index])
    index += 1   

list = [1,2,3,4,5]

for e in list:
    print(e)

2.元组(元素有序且可重复，相当于一个只读的list，不可修改)

一、定义

元组名称 = (元素1,元素2,元素3,元素4,元素5,...)

元组名称 = ()
或
元组名称 = tuple()

二、使用操作

列表.index(元素)

eg:
tuple = ('a','b','c')

print(tuple.index('a'))  # 0

len(元组)

eg:
tuple = ['a','b','c']
print(len(tuple))					# 3

元组.count(元素)

eg:
tuple = ('a','a','c')
print(tuple.count('a'))			# 2

tuple = (1,2,3,4,5)

index = 0
while index < len(元组):
    print(tuple[index])
    index += 1   

tuple = (1,2,3,4,5)

for e in tuple:
    print(e)

3.字符串(元素有序且可重复)

一、定义

str = "aaa"

字符串下标
从前向后，下标从0开始
从后向前，下标从-1开始

二、使用操作

值 = 字符串[索引]

my_str = "abcdefg"
str1 = my_str[0]				#str1值为'a'

len(字符串)

eg:
str = "abc"
print(len(str))				#3

字符串.count()

字符串.index(元素)

eg:
string = "abcd"

print(string.index("a"))  # 0

字符串.replace(字符串1,字符串2)

eg:
 str1 = "aa bb cc"
 str2 = str1.replace(bb,dd)
 print(str2)									#aa dd cc

字符串.split(分隔符)

eg:
 str = "aa,bb,cc"
 list = str.split(",")
 print(list)											#["aa","bb","cc"]

字符串.strip()					#去除字符串前后空格
字符串.strip(字符串)					#去除字符串前后指定字段

4.序列切片（用于列表，元组，字符串）

序列[起始下标:结束下标(不包含其本身):步长]
起始下标不写默认从头开始
结束下标不写默认到结尾
步长不写默认步长为1

eg:
list = ['a','b','c','d','e']
list1 = list[1:4:1]
print(list1)						#[1,2,3]

5.集合(不支持重复元素且无需，即适用于去重)

一、定义

集合名称 = {元素1,元素2,元素3,元素4,元素5,...}

集合名称 = set()

二、使用操作

len(集合)

eg:
set = {1,2,3,4,5}
print(len(set))					#5

集合.add(元素)

eg:
set = {1,2,3,4,5}
set.add(6)
print(set)							#{1,2,3,4,5,6}

集合.remove(元素)

eg:
set = {1,2,3,4,5}
set.revome(5)
print(set)							#{1,2,3,4}

集合.pop()
eg:
set = {1,2,3,4,5}
num = set.pop()
print(num)							#2

集合.clear()

集合1.difference(集合2)

eg:
set1 = {1,2,3}
set2 = {2,3,4}
set3 = set1.difference(set2)
print(set3)								#{1}

集合1.difference_update(集合2)

eg:
set1 = {1,2,3}
set2 = {2,3,4}
set1.difference_update(set2)
print(set1)								#{1}

集合1.union(集合2)

eg:
set1 = {1,2,3}
set2 = {2,3,4}
set3 = set1.union(set2)
print(set3)								#{1, 2, 3, 4}

eg:
set = {1,2,3,4,5}
for e in set:
  print(e)

6.字典(key不能重复)

key可为任意数据类型，但不能是字典类型

一、定义

dict = {key:value,key:value,key:value,key:value....}

dict = {}
或
dict = dict()

value = 字典[key]

eg:
dict = {1:'a',2:'b',3:'c',4:'d'}
print(dict[1])						#a
print(dict[2])						#b
print(dict[3])						#c
print(dict[4])						#d

eg:
dict = {"aa":{
            "语文":56,
            "数学":63
        },
        "bb":{
            "语文":75,
            "数学":58
        },
        "cc":{
            "语文":35,
            "数学":68
        }
}
print(dict["aa"]["语文"])				#56
print(dict["aa"]["数学"])				#63
print(dict["bb"]["语文"])				#75
print(dict["bb"]["数学"])				#58
print(dict["cc"]["语文"])				#35
print(dict["cc"]["数学"])				#68

二、使用操作

len(字典)

eg:
dict = {1:"aa",2:"bb",3:"cc"}
print(len(dict))									#3

字典[key] = value

字典[key] = new value

字典.pop(key)

eg:
dict = {1:"aa",2:"bb",3:"cc"}
dict.pop(1)
print(dict)													#{2: 'bb', 3: 'cc'}

字典.clear()

字典.keys()

eg:
dict = {1:"aa",2:"bb",3:"cc"}
keys = dict.keys()
print(keys)													#dict_keys([1, 2, 3])

eg:
dict = {1:"aa",2:"bb",3:"cc"}
for key in dict.keys():
    print(key,dict[key])

五、

（一）对象

1.定义对象

成员变量：定义在类中的属性
成员方法：定义在类中的函数

一、定义类

通过class关键字

class	类名:
  类的属性
  ...

二、成员方法

（一）构造方法

在创建对象是自动执行，并将传入的参数自动传递给构造方法，将成员变量赋值

def _init_(self,形参1,形参2,形参3,....):
    self.成员变量1 = 形参1
    self.成员变量2 = 形参2
    self.成员变量3 = 形参3
    ...

class person:
  name = None												#若定义构造方法可省略
  age = None												#若定义构造方法可省略

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

p = person("aa",18)
print(p.name,p.age)									#aa 18

（二）一般的成员方法

def 方法名(self,形参1,形参2,形参3,....):
    函数体

class person:
  name = None
  age = None
  gender = None

  def f(self):
    print("holle")

p = person()
p.f					

（三）在成员方法中访问成员变量

通过self关键字，self.变量名实现访问成员变量

class person:
  name = None
  age = None
  gender = None

  def f(self):
    print(self.name,self.age,self.gender)
    
p = person()
p.f()    											#None None None

2.创建对象

变量名 = 类名()

3.属性赋值

一、调用成员变量赋值

变量名.属性名 = 值

class person:
  name = None
  age = None
  
p = person()
p.name = "aa"
p.age = 18
print(p.name,p.age)							#aa 18

二、通过构造方法赋值

变量名 = 类名(参数1,参数2,参数3,...)

class person:
  name = None												
  age = None												

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

p = person("aa",18)
print(p.name,p.age)									#aa 18

（二）封装

指的是将属性和方法打包在一起，并隐藏对象的内部实现细节，只暴露必要的接口供外部使用

1.私有成员变量 方法

无法被类对象直接调用使用，但内部其他成员可以直接使用
变量/方法名以__(两个下划线)为开头

2.访问私有成员变量

getter setter方法

class MyClass:
    def __init__(self):
        self.__private_var = 42
    
    def get_private_var(self):
        return self.__private_var
    
    def set_private_var(self, value):
        if isinstance(value, int):
            self.__private_var = value

mc = MyClass()
print(mc.get_private_var())  # 访问私有变量
mc.set_private_var(100)      # 修改私有变量

（三）继承

1.继承

一个类（子类）继承另一个类（父类）的属性和方法。通过继承，子类可以复用父类的代码，并在需要时进行扩展或修改。

class 子类类名(父类类名):
  ...

class Parent:
    value = "父"

class Child(Parent):
    child_value = "子"
    

2.复写

子类对继承来的父类中的方法进行修改

class Parent:
    value = "父"
    
    def show(self):
        print("这是父类")

class Child(Parent):
    value = "子"									#复写父类的属性
    
    def show(self):								#复写父类的方法
        print("这是子类")


c = Child()
c.show()
print(c.value)  # 继承的属性

3.子类中调用父类方法

一、方法一

调用成员变量：父类名.成员变量
调用成员方法：父类名.成员方法(self)

class Parent:
    value = "父"

    def show(self):
        print("这是父类")


class Child(Parent):
    value = "子" 							 # 复写父类的属性

    def show(self): 					 # 复写父类的方法
        Parent.show(self)
        print("这是子类")
        print(f"我是子类{self.value},这是我的父类{Parent.value}")


c = Child()
c.show()
print(c.value)  

二、方法二

调用成员变量：super().成员变量
调用成员方法：super().成员方法( )

class Parent:
    value = "父"

    def show(self):
        print("这是父类")


class Child(Parent):
    value = "子"  						# 复写父类的属性

    def show(self):  					# 复写父类的方法
        super().show()
        print("这是子类")
        print(f"我是子类{self.value},这是我的父类{super().value}")


c = Child()
c.show()

（四）多态

相同类型的继承同一个父类的不同对象通过继承和方法复写完成某个行为时 , 会得到不同的状态

class animal:
    def behave(self):
        pass

class dog(animal):						#继承
    def behave(self):					#方法复写
        print("汪")

class cat(animal):						#继承
    def behave(self):					#方法复写
        print("喵")

def speak(anmial:animal):
    anmial.behave()

d = dog()
c = cat()
speak(d)
speak(c)

六、

（一）文件

1.打开、关闭文件

open(文件路径,文件打开模式,编码格式)
打开模式：
"r":只读
"w":写入(若文件已打开并从头编辑，原有内容会被删除)
"a":追加写入(若文件已打开并从头编辑，新内容会被写到原有内容之后)

f = open(".....","r","UTF-8")			#f为文件对象

with open(".....","r","UTF-8") as file:
      data = file.read()

with open(文件路径,文件打开模式,编码格式) as file:
      data = file.read()

文件对象.close()				#文件对象为打开文件时获取的那个对象

2.文件读取

先打开文件，创建文件对象

文件对象 = open(".....","r","...")

read( )方法

文件对象.read(x)			#x表示从文件中读取的数据长度,为传入x表示读取所有数据

readline( )方法

文件对象.readline()		#一次读取一行

readlines( )方法

文件对象.readlines()		#把整个文件中的内容一次性读取，返回一个列表，列表的元素为每一行的数据

for循环读取

for line in open(文件路径,文件打开模式,编码格式):		#每一个临时变量line记录文件的一行数据

若文件被打开并被读取过，无论再调用哪种方法读取，都会从上次读取到的位置继续读取

3.文件写出

先打开文件，创建文件对象

文件对象 = open(".....","w","...")

write( )方法

文件对象.write(要写入的文件内容)

flush( )方法

文件对象.flush()

调用write( )方法写入数据后,还需再调用flush方法才能将内容真正写入文件中

4.追加写入

先打开文件，创建文件对象

文件对象 = open(".....","a","...")  #文件不存在会先创建文件，若存在则会再内容最后追加写入

再调用write( )方法

文件对象.write()

（二）JSON数据格式

一种在各个编程语言中流通的数据格式
导入JSON模块

import json

dumps( )方法 把python数据转化为json数据

数据变量.dumps()

loads( )方法 把json数据转化为python数据

数据变量.loads()

七、

（一）异常

1.捕获异常

捕获常规异常(可捕获所有异常)

try:
  可能出现异常的代码
except:		
  若出现异常将要执行的代码

捕获指定异常

try:
  可能出现异常的代码
except 异常名 as 别名:			#用as关键字设置异常的别名，别名可有可无
  若出现异常将要执行的代码

捕获多个异常

try:
  可能出现异常的代码
except (异常名1,异常名2...) as 别名:			#用as关键字设置异常的别名，别名可有可无
  若出现异常将要执行的代码

else语法

try:
  可能出现异常的代码
except:		
  若出现异常将要执行的代码
else:
  若未出现异常将要执行的代码

finally语法

try:
  可能出现异常的代码
except:		
  若出现异常将要执行的代码
finally:
  无论是否出现异常都要执行的代码