python入门

变量与运算

变量

name = "文件管理系统"
print(name)
name = '文件管理系统'
print(name)
name = '''
        文件管理系统
        文件管理系统
        '''
print(name)
name1,name2,name3='一','二','三'
print(name1,name2,name3)
name1=name2=name3='一'
print(name1,name2,name3)
1
2
3
4
5
6
7
8
9
10
11
12
13

数学运算

字符串有加法，但没有减法

name1="一"
name2="二"
print(name1+name2)
1
2
3

一些简便写法

a += 1  # a = a + 1
a -= 1   # a = a - 1
a *= 10 # a = a * 10
a /= 2  # a = a / 2
1
2
3
4

循环、数据、判断

条件判断

关于if-else

a=True
if a:
    print("a为真")
else:
    print("a为假")
1
2
3
4
5

判断条件

if-elif-else

a=3
if a==1:
    print("a为1")
elif a==2:
    print("a为2")
elif a==3:
    print("a为3")
else:
    print("a为其他数字")
1
2
3
4
5
6
7
8
9

for和while循环

for循环

for i in range(5):
    print("第一组"+str(i))
for i in range(2,5):
    print("第二组"+str(i))
for i in range(1,10,2):
    print("第三组"+str(i))
1
2
3
4
5
6

这里没有直接+i的原因是字符串没办法和数字直接相连，所以我们通过str将数字转换成了字符串

while循环

i=10
while i>0:
    print(i)
    i-=1
1
2
3
4

continue和break

if 条件:
	break/continue
1
2

数据种类

List列表 [ ] （有顺序）

在列表中，你可以存放不同类型的元素，字符，数字，甚至列表里还能有列表

a=[1,"hello",[1,2,3],2]
print(a)
print(a[0])
print(a[1:3])
print(a[:-1])
print(a[2][2])
a[0]="world"
print(a)
1
2
3
4
5
6
7
8

Dict字典 { } （无顺序）

a={"name":["张三","李四","王五"],"age":[18,19,20],"sex":"男"}
print(a)
print(a["name"])
a["name"]="张三"
print(a)
1
2
3
4
5

Tuple元组( ) （有顺序，不可更改）

a=(1,2,3)
print(a[0])
a[0]=4
print(a)
1
2
3
4

Set集合 （无顺序）

在Python中，你可以使用多种方法来创建集合（set）。以下是常见的集合创建方法：

1. 使用大括号 {}：
   你可以使用大括号来创建一个空集合或包含元素的集合。例如：

   # 创建一个空集合
   empty_set = set()
   
   # 创建一个包含元素的集合
   my_set = {1, 2, 3}
   1
   2
   3
   4
   5

   请注意，如果你只使用大括号创建一个空的花括号 {}，Python会将其解释为一个空的字典而不是集合。

2. 使用 set() 构造函数：
   你可以使用 set() 构造函数来创建一个空集合或从其他可迭代对象（如列表、元组或字符串）创建集合。例如：

   # 创建一个空集合
   empty_set = set()
   
   # 从列表创建集合
   my_list = [1, 2, 3, 2, 1]
   my_set = set(my_list)  # 移除重复元素，得到 {1, 2, 3}
   
   # 从字符串创建集合（会将字符串拆分为字符）
   my_string = "hello"
   char_set = set(my_string)  # 得到 {'h', 'e', 'l', 'o'}
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10

3. 使用推导式：
   你可以使用集合推导式来根据某个条件从其他可迭代对象创建集合。例如：

   # 使用集合推导式创建一个包含偶数的集合
   even_set = {x for x in range(10) if x % 2 == 0}  # 得到 {0, 2, 4, 6, 8}
   1
   2

这些是创建集合的常见方法。集合是无序的、可变的数据结构，可以用于存储唯一的元素。无论你选择哪种方法，都可以根据需要创建和操作集合。

a={1,2,3,4}
b={3,4,5}
print(a.intersection(b))
print(a.union(b))
print(a.difference(b))
1
2
3
4
5

在循环中运用

上面这些，特别是列表和字典，是经常和循环一起用的

files=["one","two","three","four"]
print(len(files))
#通过索引
for i in range(len(files)):
    print("i的值依次为",i)
    print(files[i])
#直接取出数据
for i in files:
    print(i)
1
2
3
4
5
6
7
8
9

字典也能和 for 进行简化的应用。我们只需要调用 dict.items(), dict.keys(), dict.values() 分别取字典的某些部分就能简化 for 循环了

files={"name":["张三","李四","王五"],"age":[18,19,20],"sex":"男"}
for key in files.keys():
    print(key)
for value in files.values():
    print(value)
for key,value in files.items():
    print(key,value)
1
2
3
4
5
6
7

自带功能

列表的自带功能

files=[]
for i in range(5):
    files.append("添加进入了"+str(i))
    print(files)
for i in range(len(files)):
    print(files.pop())
    print(files)

a=["hello","world"]
a.extend(["python","java"])
print(a)

a.insert(1,"C++")
print(a)

del a[1]
print(a)

a.remove("java")
print(a)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

字典的自带功能

files={"name":["张三","李四","王五"],"age":[18,19,20],"sex":"男"}
print(files["name"])
print(files.get("name","如果不存在显示这里的值"))
print(files.get("hello","如果不存在显示这里的值"))

files.update({"hobby":["篮球","足球"]})
print(files)

print(files.pop("hobby"))
print(files)
1
2
3
4
5
6
7
8
9
10

函数、类、模块

函数Function

定义函数

def hello(name):
    print("hello",name)
    print("hello"+name)
hello("张三")

def nihao():
    print("你好")
nihao()
1
2
3
4
5
6
7
8

我们发现现在的函数都是使用了直接打印出来一个结果，我们如果只想要函数处理后的数据进行后续运算并不想直接打印出来怎么办呢？这个时候就要用到我们的return

def pai(r):
    return 3.14*r*r
a=pai(2)
print(a)


def paii(r):
    print(3.14*r*r)
a=paii(2)
print(a)
1
2
3
4
5
6
7
8
9
10

我们发现出现了2个12.56，似乎不用return函数的值也可以被变量接收用于后续运算，但是事实真的如此吗，我们发现还出现了一个None，这个None从何而来？

在代码中，有两个函数 pai 和 paii，它们都计算圆的面积，但它们的行为略有不同，这是为什么结果不同的原因。

1. pai 函数返回面积值：

   def pai(r):
       return 3.14 * r * r
   a = pai(2)
   print(a)
   1
   2
   3
   4

   这个函数 pai 接受半径 r 作为参数，并计算圆的面积，然后将面积值返回。在这里，您将半径为2的圆的面积计算并赋值给变量 a，然后将 a 的值打印出来，所以输出是 12.56，这是正确的。

2. paii 函数在函数内部直接打印面积值：

   def paii(r):
       print(3.14 * r * r)
   a = paii(2)
   print(a)
   1
   2
   3
   4

   这个函数 paii 也接受半径 r 作为参数，但它不返回面积值，而是直接在函数内部打印面积值。然后，您调用了 paii(2)，这会计算并打印出面积值 12.56。但是，由于函数 paii 没有明确返回任何值，所以在 a = paii(2) 中，a 实际上被赋予了 None，因为函数没有显式返回任何内容。接着，您尝试打印 a，所以输出中会出现 None。

要获得一致的结果，您可以选择使用 pai 函数，因为它会返回面积值，而不会产生 None。如果只需要计算并打印面积，那么使用 paii 函数也是可以的，只需注意它不会返回值，所以不要试图将其赋值给变量。

参数设置

def f(a,b,c):
    return a+b+c
print(f(1,2,3))#按照顺序传参
print(f(b=1,a=2,c=3))#按照参数名传参，顺序可以变

#还可以设置参数默认值
def f(a,b,c=10):
    return a+b+c
print(f(1,2))#按照顺序传参
print(f(1,2,3))#按照参数名传参，顺序可以变
1
2
3
4
5
6
7
8
9
10

全局和局部变量

# a是局部变量
def f():
    a=1
    print(a)
f()
print(a)
1
2
3
4
5
6

# b是全局变量
b=1
def f():
    print(b)
f()
print(b)
1
2
3
4
5
6

那么我们现在想到一个问题，如果在函数内部修改全局变量，这个全局变量的值会因此而改变吗？

# b是全局变量
b=1
def f():
    print(b)
    b=100
f()
print(b)
1
2
3
4
5
6
7

程序直接出错了，为什么呢?

这里代码存在一个作用域问题。在函数内部，Python首先会查找本地作用域，然后是封闭作用域，最后是全局作用域。如果在函数内部尝试访问一个变量，Python会认为它是一个本地变量，而不会查找到全局变量。因此，在函数内部，如果您尝试打印 b，但在函数内部没有定义 b，它会引发错误。

在这段代码中，我们首先在函数内部尝试打印 b，然后才定义了 b。这会导致在函数内部尝试访问未定义的本地变量 b，从而引发错误。

故我们要把b=100的位置提前

# b是全局变量
b=1
def f():
    b=100
    print(b)
f()
print(b)
1
2
3
4
5
6
7

此时我们发现，在函数内部重新给全局变量赋值，函数内部使用的赋值后的值，但是函数外依然是全局变量原来的值。

但是我们存在一种需求，如果我想在函数内部执行某段代码的时候把全局变量的值修改后函数内外都可以用怎么处理呢？这时候我们需要用到global提出申请

# b是全局变量
b=1
def f():
    global b #提出申请
    b=100
    print(b)
f()
print(b)
1
2
3
4
5
6
7
8

类Class

类的出现可以理解为是为了集合很多函数，便于使用和管理，比如猫作为一个类，这个猫类就可以有跑、跳、抓等各种函数（我们通常约定类的名字要首字母大写）

定义类

class Cat:
    def __init__(self):
        self.name = "小猫"
        self.age = 3
mycat=Cat()
print(mycat.name)
print(mycat.age)

mycat.name="大猫"
print(mycat.name)
1
2
3
4
5
6
7
8
9
10

我们来细细解释下这段代码

首先我定义了一个class类叫做cat，然后我们定义类中的一个函数，__init__()，这个可以理解成初始化一些设置，可以理解为猫的共性，那么我后面通过这里类的猫都叫小猫，年龄都是3，并且当我直接使用类时，会默认使用这个初始化函数，self可以理解成类的索引，类的什么属性或功能都能通过self来获取，self可以理解成为了锁定每个函数的位置

我们定义的类是一个概念，什么意思呢？就好比设计的图纸，我们拿到只是知道如何设计出来，但是没办法直接使用，所以我们使用类的时候，要定义一个变量去接受这个类（概念）,也就是mycat=Cat()，就相当于把设计图纸上的内容真正做出来了

类的功能

class Cat:
    def __init__(self,name,age=3):
        self.name = name
        self.age = age
mycat=Cat("白白",2)
print(mycat.name)
print(mycat.age)
1
2
3
4
5
6
7

你也可以定义一些新的函数来使用（每次新建的函数都要有一个self用于指向自己）：（再次理解一下return的用法）

class Cat:
    def __init__(self,name,age=3):
        self.name = name
        self.age = age
    def jump(self):
        print(self.name+"猫在跳")
mycat=Cat("白白",2)
mycat.jump()

class Cat:
    def __init__(self,name,age=3):
        self.name = name
        self.age = age
    def jump(self):
        return(self.name+"猫在跳")
mycat=Cat("白白",2)
print(mycat.jump())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

那么可能有些人就有一个问题，一个类下的不同函数的参数名能一样吗，都是self.参数名的形式如何区分是哪个函数的？其实我们是通过类.函数名的方式区分

class MyClass:
    def __init__(self, value):
        self.value = value

    def set_value(self, value):
        self.value = value
        return self.value # 添加返回语句

    def print_value(self, value):
        print(value)

obj = MyClass(10)
print(obj.value)
print(obj.set_value(20))
obj.print_value(30)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Python 中一个类下的不同函数的参数名可以相同。Python 的函数参数名是局部变量，它们的作用范围限定在函数内部，不会相互干扰。以下是一个示例：

在上面的示例中，__init__、set_value 和 print_value 方法都有一个名为 value 的参数，但它们是独立的变量，不会互相干扰。每个函数内部的 value 参数只在函数内部有效，并不会影响其他函数或类的属性。

然而，尽管参数名可以相同，但最好避免给不同的函数使用相同的参数名，以防止代码可读性降低和潜在的错误发生。通常，应该为每个函数选择具有描述性的参数名，以使代码更易于理解。

同时我们要注意set_value函数要有return语句，否则当你调用 obj.set_value(20) 时，它返回的是 None。

那么如果我们想在一个类中的一个函数想用另一个函数里的值怎么办？

在一个类中，如果一个函数想要使用另一个函数里的值，你可以将这个值存储为类的实例属性，然后在其他函数中访问这个属性。这样，不同函数之间可以共享数据。以下是一个示例：

class MyClass:
    def __init__(self):
        self.value = None  # 初始化一个实例属性 value

    def set_value(self, value):
        self.value = value  # 设置实例属性 value 的值

    def print_value(self):
        if self.value is not None:
            print(f"Value is: {self.value}")
        else:
            print("Value is not set.")

# 创建一个类的实例
obj = MyClass()

# 使用 set_value 方法设置值
obj.set_value(42)

# 使用 print_value 方法获取并打印值
obj.print_value()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

在这个示例中，set_value 方法用于设置实例属性 value 的值，而 print_value 方法用于打印 value 的值。通过这种方式，你可以在不同的函数之间共享数据，并且可以在类的其他方法中随时访问这些数据。

继承

如果我们要同时定义一个猫类和一个狗类，我们要定义2个类

class Cat:
    def __init__(self,name,age=3):
        self.name = name
        self.age = age
    def jump(self):
        print(self.name+"猫在跳")


class Dog:
    def __init__(self,name,age=3):
        self.name = name
        self.age = age
    def jump(self):
        print(self.name+"狗在跳")
1
2
3
4
5
6
7
8
9
10
11
12
13
14

我们发现Cat和Dog类很相似，有没有什么办法可以不用重复写一样的操作呢，那么我们就想办法抽取出来一个更一般的类，让猫类和狗类去继承这个更一般的类的属性和方法啊

关于更详细的python中的继承可以看这篇文章

私有属性和功能

后面再详细解释

特殊方法

后续再解释

模块Module

如果我们的需求是一个.py文件就可以执行的就不需要模块的概念，模块是一种程序代码管理方式

文件中的代码

我们先在同一个目录下创建2个py文件

引用module

在两个py文件中分别写入代码

# file.py
def create_name(name):
    return name
1
2
3

# me.py
import file
print(file.create_name("张三"))# 输出结果为张三
1
2
3

还可以有如下引用方法

# me.py

import file as f1
print(f1.create_name("张三"))

from file import create_name
#如果引入多个函数可以用,分割，如果想引入全部函数可以用*
print(create_name("张三"))

#和class的方法使用的对比，很像
class File:
    def create_name(self,name):
        return name
f2=File()
print(f2.create_name("张三"))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

大项目的模块管理

在正规的 module 中，我们常会看到一个__init__.py文件，这个文件是用来进行包的初始化

# __init__.py
print("这是__init__.py的内容，我率先被执行")

# speak.py
def tell():
    return "你好，这里是mypackage包里的speak文件"

# 文件管理.py
from mypackage import speak
print(speak.tell())

1
2
3
4
5
6
7
8
9
10
11

更多的关于python包管理的内容可以看这篇文章python的包管理

文件管理

创建文件

f=open("new.txt","w")   #创建并打开
f.write("hello")        #写入内容
f.close()               #关闭文件

1
2
3
4

new.txt 会被创建在这个脚本的同级目录中


也可以通过 如下写法，记得加\n，不然会在一行输出

with open("new.txt","w") as f:
    f.writelines(["hello\n","world\n"])
1
2

并且经过测试发现，新写入后会覆盖掉之前写入的内容

这段代码是Python中用于打开文件的一种常见方式，它使用了上下文管理器（with语句）。让我为你解释一下这句话的含义：

with open("new.txt", "r") as f:
1

• with: with 是一个上下文管理器，它用于在代码块的执行期间管理资源（在这种情况下是文件）。使用 with 语句可以确保文件在使用完毕后会被正确关闭，即使发生异常也能保证文件关闭操作。

• open("new.txt", "r"): 这是 open 函数的调用，用于打开文件。open 函数接受两个参数：文件名和模式。在这里，"new.txt" 是文件名，"r" 是模式，表示以只读模式打开文件。这意味着你可以从文件中读取数据，但不能进行写入操作。

• as f: 这部分将打开的文件对象赋给变量 f，这个变量名是你自己选择的。通过变量 f，你可以在后续代码中操作文件内容。

所以，这行代码的含义是打开名为 “new.txt” 的文件，以只读模式 ("r") 打开，并将文件对象赋给变量 f。之后，你可以使用 f 来读取文件的内容，完成后不需要手动关闭文件，因为 with 上下文管理器会在代码块结束后自动关闭文件。

读文件

f=open("new.txt","r")
print(f.read())
f.close()
1
2
3

上面有演示如果你的记录是一个列表，你想在文件中每行记录列表当中的一个值，可以用 writelines()，那么在读文件的时候， 也可以 readlines() 直接读出来一个列表。

with open("new.txt","r") as f:
    print(f.readlines())
1
2

在如今用python比如去处理机器学习等内容时，数据量是非常大的，有可能大到读取出来内存都受不了，那我们就想到有没有什么办法可以一行一行读取呢？

with open("new.txt","r")as f:
    while True:
        line=f.readline()
        print(line)
        if not line:
            break
1
2
3
4
5
6

这段代码是一个常见的Python语句，通常用于在读取文本文件时检查是否已经到达文件的末尾。让我为你解释它的含义：

if not line:
    break
1
2

这段代码假定在此之前有一些地方定义了一个名为 line 的变量，并且正在处理文本文件的内容。下面是代码的解释：

• if not line:: 这是一个条件语句，它检查变量 line 是否为空或为假（在Python中，空字符串、空列表、空字典等等都被视为假）。如果 line 为空或假，条件成立。

• break: 如果条件成立，就执行 break 语句。break 语句用于跳出当前的循环（通常是 for 或 while 循环），即使循环的条件仍然为真。在这个上下文中，break 的目的是结束当前的循环（可能是在读取文件行时的循环），因为已经到达文件的末尾或者遇到了一个空行。

总之，这段代码的作用是检查变量 line 是否为空，如果是的话就跳出当前循环，通常是用于结束读取文件的操作，因为文件已经到达末尾或者遇到了一个空行。

文件编码，中文乱码

有的时候我们打开文件会出现一大堆看不懂的乱字符，原因就是解码和编码的规则不一致，什么意思呢？简单来说小A编码你好为A，编码的规则叫做"rule1"，而小B拿到编码好的A之后，他误以为编码的规则是"rule2"，所以他用编码规则"rule2"去解码，那么无论如何都再也得不到你好的结果。

实际运用中编码规则通常来说是 utf-8、gbk、gb2312其中的某一种。

with open("new.txt","wb")as f:
    f.write("hello你好".encode("gbk"))
with open("new.txt","rb")as f:
    print(f.read().decode("gbk"))
    print(f.read())
    print(f.read().decode("utf-8"))
1
2
3
4
5
6

我们还可以发现读取后这个文件里的内容就为空了，所以 print(f.read())和print(f.read().decode("utf-8"))并没有效果

更多读写模式

暂时不演示，后面用到我再补充