我的Python学习笔记

  语言类型 Python语言是一种解释型语言。
  编码 ：Python3 中默认编码为 UTF-8。

数据类型

• 整数：可以为任意大小、包含负数。

• 浮点数：就是小数。

• 字符串：以单引号 、双引号、三引号括起来的文本。

• 布尔：只有 True、False 两种值。

• 空值：用 None 表示。

输入输出

• print()
• input()
  返回的数据类型是字符串。

运算符

+
-
*
/
// 	整除
%	取模（取余）
** 	幂
=	赋值运算符
== 	等于
!=	不等于
>
>=
<
<=
+=
-=
*=
/=
%=
**=
//=
&	与
|	或
^	异或
~	取反
<<	左移
>>	右移
and	与
or	或
not	非
is	等于
is not	不等于

运算符优先级

由上至下对应优先级由高到低

**	幂
~ + -		取反、正号、负号
* / % //
+ - 		加法、减法
>> << 	右移、左移
&		与
^ |	异或、非
<	<=	>	>=
== !=
=
is 	is not
in 	not in 
not	and 	or 

关键字

• pass
  在Python中，pass关键字用于表示“什么都不做”。

循环语句

for

for <variable> in <sequence>:
	<code block>

while

while <condition>
	<code block>

常用函数和语句

• range()函数
  生成一个指定范围的数字序列，常用于for循环中。
  基本语法range(start,stop,step)

  for i in range(1,10,2):
      print(i)
  

• break语句和continue语句
  break用于跳出循环体
  continue语句用于跳出当前循环，进入下一循环

字符串

python 中的字符串用引号包围
打印字符串

print("Hello World!")

创建字符串变量然后打印

a="Hello World!"
print(a)

打印多行字符串

a="""
Hello
World
!
"""
print(a)

字符串索引

a="Hello World!"
print(a[4]) 	#o

遍历字符串

a="Hello World!"
for i in a:
	print(i)

字符串长度

a="Hello World!"
print(len(a))	#12

关键字in

a="Hello World!"
print('W' in a)	#True
print("Hello" in a)	#True

关键字 not in

a="Hello World!"
print('W' not in a)	#False
print("Helle" not in a)	#True

切片

string[start:end:step]

• start：切片开始的位置（包含该位置）。如果省略，默认从字符串的开头开始。
• end：切片结束的位置（不包含该位置）。如果省略，默认到字符串的末尾。
• step：步长，即每次跳过的字符数。如果省略，默认为1。

负索引

a="Hello World!"
print(a[::-1])	#!dlroW olleH

修改字符串

小写转大写
upper()方法以大写形式返回字符串

a="Hello World!"
print(a.upper())	#HELLO WORLD!

大写转小写
lower()方法以小写形式返回字符串

a="Hello World!"
print(a.lower())	#hello world!

strip()方法
  Python 中的 strip() 方法用于移除字符串两端的空格或指定字符。这个方法不会修改原始字符串，而是返回一个新的字符串，它是原始字符串的副本，但已经去掉了两端的指定字符。
str.strip([chars])

• chars：一个字符串，包含需要被移除的字符。如果省略此参数，则默认移除空白字符（如空格、换行符 \n、制表符 \t 等）。

a="  Hello World!  "
print(a.strip())	#Hello World!

替换字符串
  replace() 方法用于将字符串中的某些子串替换为另一个子串。这个方法返回一个新的字符串，它是原始字符串的副本，但已经替换了指定的子串。
str.replace(old, new, count)

• old：需要被替换的子串。
• new：用来替换 old 的子串。
• count：可选参数，指定替换的最大次数。如果省略此参数，则替换所有出现的子串。

a="Hello World!"
print(a.replace('H','R'))	#Rello World!

拆分字符串
  split() 方法用于将字符串分割成多个子串，并将这些子串存储在列表中。这个方法返回一个列表，其中包含了被分割的子串。
str.split(sep=None, maxsplit=-1)

• sep：分隔符。用于分割字符串的字符或字符串。如果省略此参数或其值为 None，则默认使用任何空白字符作为分隔符（如空格、换行符 \n、制表符 \t 等）。
• maxsplit：可选参数，指定分割的最大次数。默认值为 -1，表示分割所有可能的子串。如果设置为其他整数，则只分割前 maxsplit 次。

a="Hello World!"
print(a.split(" ")) 	#['Hello', 'World!']

字符串拼接
拼接两个或多个字符串可以使用+运算符

a="Hello"
b="World"
c=a+b
d=a+" "+b
print(c) 	# HelloWorld
print(d)	# Hello World

format()格式化
: <填充> <对齐> <宽度> | <,> <.精度> <类型>

a="Hello"
print("{:*>20}".format(a))		#***************Hello
b=50000.4567
print("{:,.2f}".format(b))		#50,000.46

列表

基本形式：mylist = ['a','b','c','d']

创建列表的方式

• 直接定义
  mylist = ['a','b','c','d']
• 使用list函数将其他可迭代对象转换为列表

  demo_str = "abcdefg"
  mylist = list(demo_str)
  print(mylist) # ['a', 'b', 'c', 'd', 'e', 'f', 'g']
  

列表的长度

可以使用len()函数，返回列表的长度。

列表的数据类型

列表的数据类型可以是任意数据类型。

列表的方法

• insert(index,object)：插入

  demo_str = "abcdefg"
  mylist = list(demo_str)
  mylist.insert(len(mylist),'h')
  print(mylist) # ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
  

• append(object)：添加元素，在末尾添加

  demo_str = "abcdefg"
  mylist = list(demo_str)
  mylist.append('h')
  print(mylist) # ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
  

• extend()：合并列表

  demo_str = "abcdefg"
  mylist = list(demo_str)
  otherlist = [1,2,3,4,5,6]
  mylist.extend(otherlist)
  print(mylist) # ['a', 'b', 'c', 'd', 'e', 'f', 'g', 1, 2, 3, 4, 5, 6]
  

• remove()：删除指定元素

  demo_str = "abcdefg"
  mylist = list(demo_str)
  mylist.remove('g')
  print(mylist) # ['a', 'b', 'c', 'd', 'e', 'f']
  

• pop()：删除指定索引的元素
  如果不加索引，默认删除最后一个元素
  该方法会返回删除的元素

  demo_str = "abcdefg"
  mylist = list(demo_str)
  mylist.pop(6)
  print(tem) # g
  print(mylist) # ['a', 'b', 'c', 'd', 'e', 'f']
  

• del：删除指定的索引

  demo_str = "abcdefg"
  mylist = list(demo_str)
  del mylist[6]
  print(mylist) # ['a', 'b', 'c', 'd', 'e', 'f']
  

  del 也可以删除整个列表

  demo_str = "abcdefg"
  mylist = list(demo_str)
  del mylist
  

• clear()：清空列表

  demo_str = "abcdefg"
  mylist = list(demo_str)
  mylist.clear()
  print(mylist) # []
  

• sort()：排序

  demo_str = "abcdefg"
  mylist = list(demo_str)
  mylist.sort()
  print(mylist) # ['a', 'b', 'c', 'd', 'e', 'f', 'g']
  

• reverse()：倒序

  demo_str = "abcdefg"
  mylist = list(demo_str)
  mylist.reverse()
  print(mylist) # ['g', 'f', 'e', 'd', 'c', 'b', 'a']
  

遍历列表

• 遍历列表项

  demo_str = "abcdefg"
  mylist = list(demo_str)
  for i in mylist:
      print(i)
  

• 遍历列表索引

  demo_str = "abcdefg"
  mylist = list(demo_str)
  for i in range(len(mylist)):
      print(mylist[i])
  

• while遍历

  demo_str = "abcdefg"
  mylist = list(demo_str)
  i = 0
  while i < len(mylist):
      print(mylist[i])
      i += 1
  

列表推导式

  列表推导式（List Comprehension）是Python中一种优雅且简洁的构建列表的方法，它允许你通过一个表达式来创建列表。
  基本语法：[expression for item in iterable if condition]

• 举个例子：

  mylist = [x for x in range(1,100) if (x % 2 == 0) and (x % 3 == 0)]
  print(mylist) # [6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96]
  

元组

元祖的特性：元组中的元素是有序的、不可变的。元组一旦创建，其中的元素就不能被修改，这使得元组适合用于存储不应改变的数据。

创建元组

• 直接定义
  如果元组中只有一个元素，需要在元素后面加上逗号 , 来确保Python将其识别为元组。
  my_tuple = (1, 2, 3)
• 使用tuple()函数

  my_list = [1, 2, 3]
  my_tuple = tuple(my_list)
  print(my_tuple) # (1, 2, 3, 4, 5, 6)
  

元组的索引

通过索引下标来访问元组中的元素。

mylist = [1,2,3,4,5,6]
my_tuple = tuple(mylist)
print(my_tuple[2]) # 3

元组的修改

元组中的元素值是不允许修改的，但可以创建一个新的元组对象来包含所需的修改。

• 可以将元组转换为列表，修改后再利用列表生成元组。
• 使用切片和拼接生成新的元组。

删除元组

del

mylist = [1,2,3,4,5,6]
my_tuple = tuple(mylist)
del my_tuple

可以对元组使用的函数

• len(tuple)
  计算元组元素的个数
• max(tuple)
  返回元组中元素的最大值
• min(tuple)
  返回元组中元素的最小值

字典

创建字典

• 直接定义

  mydict = {} # 创建空字典
  my_dict = {'key1': 'value1', 'key2': 'value2'}
  print(my_dict) # {'key1': 'value1', 'key2': 'value2'}
  

• 使用dict()构造函数
  从键值对序列创建

  tuple1 = ("key1","value1")
  tuple2 = ("key2","value2")
  tuple3 = ("key3","value3")
  my_list = list()
  my_list.append(tuple1)
  my_list.append(tuple2)
  my_list.append(tuple3)
  my_dict = dict(my_list)
  print(my_dict) # {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
  

访问字典中的元素

• 通过键来访问值

  tuple1 = ("key1","value1")
  tuple2 = ("key2","value2")
  tuple3 = ("key3","value3")
  my_list = list()
  my_list.append(tuple1)
  my_list.append(tuple2)
  my_list.append(tuple3)
  
  my_dict = dict(my_list)
  print(my_dict["key1"]) # value1
  

• 使用dict.get()方法

  print(my_dict.get("key1")) # value1
  

添加或修改键值对

my_dict = dict()
my_dict["key1"] = "value1" # 添加键值对
my_dict["key1"] = "new_value1" # 修改键值对

print(my_dict)

删除字典元素/字典

tuple1 = ("key1", "value1")
tuple2 = ("key2", "value2")
tuple3 = ("key3", "value3")
my_list = list()
my_list.append(tuple1)
my_list.append(tuple2)
my_list.append(tuple3)
my_dict = dict(my_list)
del my_dict["key2"]
print(my_dict) # {'key1': 'value1', 'key3': 'value3'}
del my_dict

字典中的内置函数与方法

• len(dict)
  计算字典中元素的个数

• dict.clear()
  删除字典内所有元素

• dict.keys()

  print(my_dict.keys()) # dict_keys(['key1', 'key2', 'key3'])
  

• dict.values()

  print(my_dict.values()) # dict_values(['value1', 'value2', 'value3'])
  

• dict.items()

  print(my_dict.items()) # dict_items([('key1', 'value1'), ('key2', 'value2'), ('key3', 'value3')])
  

• dict.update(dict2)
  把字典dict2的键/值更新到dict里

• dict.pop(key)
  删除字典key对应的键以及值，返回被删除的值

集合

Python中的集合（set）是一个无序且不重复的元素集合。

集合的创建

• 使用{}创建

  my_set = {1,2,3,4,5,6,7,8,9}
  print(my_set) # {1, 2, 3, 4, 5, 6, 7, 8, 9}
  

• 使用set函数创建

  my_list=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  my_set = set(my_list)
  print(my_set) # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
  

集合中的方法

• add()添加元素

  my_list=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  my_set = set(my_list)
  my_set.add('a')
  print(my_set) # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'a'}
  

• remove()移除元素
  元素不存在，会报错

  my_list=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  my_set = set(my_list)
  my_set.remove(10)
  print(my_set) # {1, 2, 3, 4, 5, 6, 7, 8, 9}
  

• discard()移除元素
  元素不存在，不报错

  my_list=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  my_set = set(my_list)
  my_set.discard(10)
  print(my_set)
  

• pop()
  将集合进行无序的排序，然后将这个无序集合最左边的第一个元素进行删除

  my_list=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  my_set = set(my_list)
  my_set.pop()
  print(my_set)
  

• clear()清空集合

  my_list=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  my_set = set(my_list)
  my_set.clear()
  print(my_set) # 
  

函数

def func():
	"code block"
	return

文件I/O

open

file = open('path','mode')

with open('path','mode') as file:

mode参数

模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
+	打开一个文件进行更新(可读可写)。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
b	二进制模式
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
rb+	以二进制格式打开一个文件用于读写。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

File的内置方法

• close()
  关闭文件

  file.close()
  

• read()

  content = file.read([length])
  

  length是要读取文件的字节数，默认读取所有。
• readline()
  读取整行（单行）

  content = file.readline([size])
  

  size是要读取的字节数，包括换行符
• readlines()

  content = file.readlines([size])
  

  读取所有行，size指定要读取的字节数
• file.write(str)
  将字符串写入文件
• file.tell()
  返回指针在当前文件中的位置
• file.seek(offset,[from])
  Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。

with open("123.txt","w") as f:
    f.write("Hello World!")

with open("123.txt","r") as f:
    text = f.read()
    print(text) # Hello World!

with open("123.txt","w+") as f:
    f.write("Hello World!")
    position = f.tell()
    print(position) # 12
    f.seek(2,0)
    position = f.tell()
    print(position) # 2
with open("123.txt","r") as f:
    text = f.read()
    print(text) # Hello World!

面向对象

类与对象

类
类定义了一组属性和方法，这些属性和方法描述了对象的状态和行为。
对象
对象是类的具体实例，表示一个实际存在的实体。
类的定义

	class Clazz:
	    def __init__(self):
        	print("inited")
	    attribute1 = 1;
	    attribute2 = 2;
	    attribute3 = 3;
	    def method1(self):
	        print("method1")
	    def method2(self):
	        print("method2")

创建对象

if __name__ == "__main__":
    class01 = Clazz();
    class01.method1() # method1

属性

  在面向对象编程（OOP）中，属性（Attributes）是用来描述对象特征的数据。属性通常分为 实例属性 和 类属性，它们分别代表不同类型的数据和应用场景。
实例属性
  实例属性是与每个对象实例独立相关的属性。每个对象都有自己的实例属性，彼此不共享。通常在 __init__ 方法（构造方法）中定义，使用 self 关键字来指定。

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

# 创建对象并访问实例属性
person1 = Person("Alice", 25)
person2 = Person("Bob", 30)

print(person1.name)  # 输出: Alice
print(person2.age)   # 输出: 30

在这里，name 和 age 是实例属性。每个对象都有独立的 name 和 age 值。
类属性
  类属性是由类本身所有的属性，而不是任何特定的实例所独有的。类属性对于类的所有实例都是共享的。类属性通常在类的定义中直接声明，不在__init__方法中声明。

class Car:
    wheels = 4  # 类属性

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

# 创建对象并访问属性
car1 = Car("Red")
car2 = Car("Blue")

print(car1.wheels)  # 输出: 4
print(car2.wheels)  # 输出: 4
print(Car.wheels)   # 输出: 4

# 修改类属性
Car.wheels = 5
print(car1.wheels)  # 输出: 5
print(car2.wheels)  # 输出: 5

wheels 是类属性，所有 Car 实例都共享它。如果修改 Car.wheels，则所有对象的 wheels 值都随之改变。
私有属性
  通过将属性名称前加上双下划线（如 __private_attr）来声明私有属性，表明这些属性不希望被外部直接访问。

class BankAccount:
    def __init__(self, initial_balance):
        self.__balance = initial_balance  # 私有属性
    
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
        else:
            print("Insufficient funds.")

    def get_balance(self):
        return self.__balance

# 创建 BankAccount 对象并访问私有属性
account = BankAccount(1000)
print(account.get_balance())  # 输出: 1000
# print(account.__balance)    # 会报错，无法直接访问私有属性

属性的动态添加与删除

class Person:
    def __init__(self, name):
        self.name = name

person = Person("Alice")

# 动态添加属性
person.age = 25
print(person.age)  # 输出: 25

del person.age  # 删除 age 属性
# print(person.age)  # 会报错，因为属性已删除

方法

实例方法
  实例方法是最常见的类方法，用于操作实例对象的数据。实例方法的第一个参数通常是 self，用于表示调用该方法的实例本身。

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

    def bark(self):  # 实例方法
        print(f"{self.name} is barking!")

dog = Dog("Buddy")
dog.bark()  # 输出: Buddy is barking!

  bark是一个实例方法，可以通过对象 dog 调用。self 参数指的是调用该方法的实例对象。
类方法
  类方法是作用于类本身的方法，而不是某个实例。类方法的第一个参数是 cls，表示类本身。可以使用 @classmethod 装饰器来定义类方法

class Dog:
    species = "Canis lupus"  # 类属性

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

    @classmethod
    def get_species(cls):  # 类方法
        return cls.species

print(Dog.get_species())  # 输出: Canis lupus

静态方法
  静态方法不涉及实例或类的任何特定数据，只是一种封装在类中的普通函数。静态方法可以使用 @staticmethod 装饰器定义，静态方法没有 self 或 cls 参数。

class MathUtils:
    @staticmethod
    def add(a, b):  # 静态方法
        return a + b

print(MathUtils.add(5, 3))  # 输出: 8

构造方法
__init__：构造方法，在创建对象时自动调用，用于初始化实例。
析构方法
  析构方法是用于在对象生命周期结束时执行清理操作的特殊方法。
  析构方法的名称为 del，当对象被删除或超出作用域、不再使用时，Python 会自动调用它。

    def __del__(self):  # 析构方法
        print("File closed.")

封装

  在Python中，封装（Encapsulation）是一种面向对象编程（OOP）的基本概念，它用于将数据和行为（方法）结合在一起，并隐藏内部细节，以实现数据保护和模块化。这使得对象的内部状态只能通过定义的接口进行访问和修改，而不能被外部直接操作，从而提高了代码的安全性和可维护性。

继承

  在Python中，继承是面向对象编程（OOP）的一项重要特性，它允许我们创建一个新的类（子类或派生类），并自动获得另一个类（父类或基类）的属性和方法。继承使得代码可以重用，并在需要时扩展或修改基类的行为。
  通过继承，子类不仅可以直接使用父类的已有功能，还可以通过方法重写来更改父类的某些行为。Python还支持多重继承，这允许一个子类从多个父类继承属性和方法。

继承的实现
  继承是通过在类名后括号中写上父类名称来实现的。

class Animal:
    def speak(self):
        return "Animal sounds"

class Dog(Animal):
    def bark(self):
        return "Woof!"

dog = Dog()
print(dog.speak())  # 输出：Animal sounds
print(dog.bark())   # 输出：Woof!

在子类中调用父类方法
  在子类中，如果我们想调用父类的某个方法，可以使用super()函数。

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        return "Animal sounds"

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)  # 调用父类的__init__方法
        self.breed = breed

    def speak(self):
        return "Bark!"  # 重写父类的方法

dog = Dog("Buddy", "Golden Retriever")
print(dog.name)      # 输出：Buddy
print(dog.speak())   # 输出：Bark!

方法的重写（Overriding）
  方法重写是指子类中定义与父类相同名称的方法，以实现不同的功能。

class Animal:
    def speak(self):
        return "Animal sounds"

class Dog(Animal):
    def speak(self):  # 重写父类的speak方法
        return "Woof!"

class Cat(Animal):
    def speak(self):  # 重写父类的speak方法
        return "Meow!"

dog = Dog()
cat = Cat()
print(dog.speak())  # 输出：Woof!
print(cat.speak())  # 输出：Meow!

多继承

class Walkable:
    def walk(self):
        return "Walking"

class Swimmable:
    def swim(self):
        return "Swimming"

class Amphibian(Walkable, Swimmable):
    pass

frog = Amphibian()
print(frog.walk())  # 输出：Walking
print(frog.swim())  # 输出：Swimming

多态

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

def make_sound(animal):
    print(animal.speak())

dog = Dog()
cat = Cat()

make_sound(dog)  # 输出：Woof!
make_sound(cat)  # 输出：Meow!