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+1=2 |
| - | 减 | 2-1=1 |
| * | 乘 | 1*2=2 |
| / | 除 | 3/2=1.5 |
| % | 取模 | 13%10=3 |
| ** | 幂 | 2**3=8 |
| // | 取整除 | 10//3=3 |
字符串有加法，但没有减法
name1="一"
name2="二"
print(name1+name2)
一些简便写法
a += 1 # a = a + 1
a -= 1 # a = a - 1
a *= 10 # a = a * 10
a /= 2 # a = a / 2
循环、数据、判断
条件判断
关于if-else
a=True
if a:
print("a为真")
else:
print("a为假")
判断条件
| 判断 | 含义 |
|---|---|
| a==b | a是否等于b |
| a>b | a是否大于b |
| a>=b | a是否大于等于b |
a| a是否小于b |
|
| a<=b | a是否小于等于b |
| a!=b | a是否不等于b |
| and | 两边都为True为真 |
| or | 有一个为True为真 |
| not | 取反 |
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为其他数字")
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))
这里没有直接+i的原因是字符串没办法和数字直接相连，所以我们通过str将数字转换成了字符串
while循环
i=10
while i>0:
print(i)
i-=1
continue和break
if 条件:
break/continue
| 命令 | 含义 |
|---|---|
| break | 跳出整个循环（如果有两层循环，最内层的循环用了这个只跳出内层循环） |
| continue | 跳过本次循环（如果后续还满足循环条件继续，只跳过一次，而不是整个循环） |
数据种类
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)
Dict字典 { } （无顺序）
a={"name":["张三","李四","王五"],"age":[18,19,20],"sex":"男"}
print(a)
print(a["name"])
a["name"]="张三"
print(a)
Tuple元组( ) （有顺序，不可更改）
a=(1,2,3)
print(a[0])
a[0]=4
print(a)
Set集合 （无顺序）
在Python中，你可以使用多种方法来创建集合（set）。以下是常见的集合创建方法：
-
使用大括号
{}：
你可以使用大括号来创建一个空集合或包含元素的集合。例如：# 创建一个空集合 empty_set = set() # 创建一个包含元素的集合 my_set = {1, 2, 3}请注意，如果你只使用大括号创建一个空的花括号
{}，Python会将其解释为一个空的字典而不是集合。 -
使用
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'} -
使用推导式：
你可以使用集合推导式来根据某个条件从其他可迭代对象创建集合。例如：# 使用集合推导式创建一个包含偶数的集合 even_set = {x for x in range(10) if x % 2 == 0} # 得到 {0, 2, 4, 6, 8}
这些是创建集合的常见方法。集合是无序的、可变的数据结构，可以用于存储唯一的元素。无论你选择哪种方法，都可以根据需要创建和操作集合。
| 命令 | 含义 |
|---|---|
| intersection | 交集 |
| union | 并集 |
| difference | 补集 |
a={1,2,3,4}
b={3,4,5}
print(a.intersection(b))
print(a.union(b))
print(a.difference(b))
在循环中运用
上面这些，特别是列表和字典，是经常和循环一起用的
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)
字典也能和 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)
自带功能
列表的自带功能
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)
| 命令 | 功能 |
|---|---|
| append | 从末尾添加 |
| pop | 从末尾取出 |
| extend | 两个列表合并 |
| insert | 按位置添加 |
| del | 按索引删除 |
| remove | 按值移除 |
字典的自带功能
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)
函数、类、模块
函数Function
定义函数
def hello(name):
print("hello",name)
print("hello"+name)
hello("张三")
def nihao():
print("你好")
nihao()
我们发现现在的函数都是使用了直接打印出来一个结果，我们如果只想要函数处理后的数据进行后续运算并不想直接打印出来怎么办呢？这个时候就要用到我们的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)
我们发现出现了2个12.56，似乎不用return函数的值也可以被变量接收用于后续运算，但是事实真的如此吗，我们发现还出现了一个None，这个None从何而来？
在代码中，有两个函数 pai 和 paii，它们都计算圆的面积，但它们的行为略有不同，这是为什么结果不同的原因。
-
pai函数返回面积值：def pai(r): return 3.14 * r * r a = pai(2) print(a)这个函数
pai接受半径r作为参数，并计算圆的面积，然后将面积值返回。在这里，您将半径为2的圆的面积计算并赋值给变量a，然后将a的值打印出来，所以输出是12.56，这是正确的。 -
paii函数在函数内部直接打印面积值：def paii(r): print(3.14 * r * r) a = paii(2) print(a)这个函数
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))#按照参数名传参，顺序可以变
全局和局部变量
| 变量 | 特点 |
|---|---|
| 全局global | 函数内外都能用 |
| 局部local | 仅函数内使用 |
# a是局部变量
def f():
a=1
print(a)
f()
print(a)
# b是全局变量
b=1
def f():
print(b)
f()
print(b)
那么我们现在想到一个问题，如果在函数内部修改全局变量，这个全局变量的值会因此而改变吗？
# b是全局变量
b=1
def f():
print(b)
b=100
f()
print(b)
程序直接出错了，为什么呢?
这里代码存在一个作用域问题。在函数内部，Python首先会查找本地作用域，然后是封闭作用域，最后是全局作用域。如果在函数内部尝试访问一个变量，Python会认为它是一个本地变量，而不会查找到全局变量。因此，在函数内部，如果您尝试打印 b，但在函数内部没有定义 b，它会引发错误。
在这段代码中，我们首先在函数内部尝试打印 b，然后才定义了 b。这会导致在函数内部尝试访问未定义的本地变量 b，从而引发错误。
故我们要把b=100的位置提前
# b是全局变量
b=1
def f():
b=100
print(b)
f()
print(b)
此时我们发现，在函数内部重新给全局变量赋值，函数内部使用的赋值后的值，但是函数外依然是全局变量原来的值。
但是我们存在一种需求，如果我想在函数内部执行某段代码的时候把全局变量的值修改后函数内外都可以用怎么处理呢？这时候我们需要用到global提出申请
# b是全局变量
b=1
def f():
global b #提出申请
b=100
print(b)
f()
print(b)
类Class
类的出现可以理解为是为了集合很多函数，便于使用和管理，比如猫作为一个类，这个猫类就可以有跑、跳、抓等各种函数（我们通常约定类的名字要首字母大写）
定义类
class Cat:
def __init__(self):
self.name = "小猫"
self.age = 3
mycat=Cat()
print(mycat.name)
print(mycat.age)
mycat.name="大猫"
print(mycat.name)
我们来细细解释下这段代码
首先我定义了一个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)
你也可以定义一些新的函数来使用（每次新建的函数都要有一个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())
那么可能有些人就有一个问题，一个类下的不同函数的参数名能一样吗，都是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)
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()
在这个示例中，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+"狗在跳")
我们发现Cat和Dog类很相似，有没有什么办法可以不用重复写一样的操作呢，那么我们就想办法抽取出来一个更一般的类，让猫类和狗类去继承这个更一般的类的属性和方法啊
关于更详细的python中的继承可以看这篇文章
私有属性和功能
后面再详细解释
特殊方法
后续再解释
模块Module
如果我们的需求是一个.py文件就可以执行的就不需要模块的概念，模块是一种程序代码管理方式
文件中的代码
我们先在同一个目录下创建2个py文件
引用module
在两个py文件中分别写入代码
# file.py
def create_name(name):
return name
# me.py
import file
print(file.create_name("张三"))# 输出结果为张三
还可以有如下引用方法
# 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("张三"))
大项目的模块管理
在正规的 module 中，我们常会看到一个__init__.py文件，这个文件是用来进行包的初始化
| 序号 | 作用 |
|---|---|
| 1 | python3.3之前必须要在文件夹下引用这个文件，才可以将文件夹作为包导入（现在基本不是用于这个功能了） |
| 2 | 文件夹作为包导入时，python会自动执行__init__.py中的代码，然后再执行或导入其他文件的代码 |
# __init__.py
print("这是__init__.py的内容，我率先被执行")
# speak.py
def tell():
return "你好，这里是mypackage包里的speak文件"
# 文件管理.py
from mypackage import speak
print(speak.tell())
