Python 入门教程详细版全集（两周速成）

一、初始Python

打开CMD（命令提示符）程序，输入Python并回车。然后，在里面输入代码回车即可立即执行。

 Tip1:找不到“命令提示符”程序在哪里？

使用快捷键：win + r;打开运行框，输入cmd后回车即可打开命令提示符程序

Tip2:安装python的时候，务必勾选:add python 3.10to PATH的选项；

二、常见的值类型

Python中常用的有6种值(数据)的类型

字符串
字符串(string)，又称文本，是由任意数量的字符如中文、英文、各类符号、数字等组成。所以叫做字符的串；

字符串需要用双引号(")包围起来被引号包围起来的，被引号包围起来的,都是字符串。

注释:在程序代码中对程序代码进行解释说明的文字。

# 我是单行注释
print("Hello World")
# 注意：#号和注释内容一般建议以一个空格隔开

# 多行注释:以一对三个双引号引起来("""注释内容""")来解释说明一段代码的作用使用方法
"""
   Hello
   World
    !
"""
print("Hello")
print("World")
print("!")

字符串在Python中有多种定义形式:

单引号定义法:name=‘Lotus’
双引号定义法:name ="Lotus"
三引号定义法:name ="""Lotus""”

三引号定义法，和多行注释的写法一样，同样支持换行操作。使用变量接收它，它就是字符串
不使用变量接收它，就可以作为多行注释使用.

字符串拼接
如果我们有两个字符串(文本)字面量，可以将其拼接成一个字符串，通过+号即可完成，如:

print("hello"+"world")
# 输出：hello world

面量和变量或变量和变量之间会使用拼接，如

name = 'lotus'
print("my name :" + name + ", hello world")
#输出：my name :lotus, hello world

字符串格式化

% 表示:我要占位
s表示:将变量变成字符串放入占位的地方
所以，综合起来的意思就是:我先占个位置，等一会有个变量过来，我把它变成字符串放到占位的位置;多个变量占位,变量要用括号括起来,并按照占位的顺序填入。

字符串格式化-数字精度控制

m，控制宽度，要求是数字(很少使用),设置的宽度小于数字自身，不生效·.n，控制小数点精度，要求是数字，会进行小数的四舍五入示例:
%5d:表示将整数的宽度控制在5位，如数字11，被设置为5d，就会变成:[空格][空格][空格]11，用三个空格补足宽度。
%5.2f:表示将宽度控制为5，将小数点精度设置为2
小数点和小数部分也算入宽度计算。如，对11.345设置了%7.2f后，结果是:[空格][空格111.35。2个空格补足宽度，小数部分限制2位精度后，四舍五入为.35

 

三、变量

变量:在程序运行时，能储存计算结果或能表示值的抽象概念。简单的说，变量就是在程序运行时，记录数据用的。

变量的定义格式  变量名称 = 变量的值

标识符命名规则-内容限定

标识符命名中，只允许出现:英文、中文（不推荐使用中文）、数字（数字不可以开头）、下划线

#定义一个变量，用来记录钱包余额

money=50

#通过print语句，输出变量记录的内容
#格式：print(内容1，内容2，内容3，.....)
print("钱包还有:” ,money)

 变量为两类:局部变量和全局变量

局部变量指的是变量的作用范围(变量在哪里可用，在哪里不可用)

所谓局部变量是定义在函数体内部的变量，即只在函数体内部生效

所谓全局变量，指的是在函数体内、外都能生效的变量

# 定义全局变量a
num =100
def testA():
    print(num)#访问全局变量num，并打印变量num存储的数据
 def testB():
    print(num)#访问全局变量num，并打印变量num存储的数据

testA()
testB()
#100
# 100

四、运算符

 算术(数学)运算符

赋值运算符

复合赋值运算符

 比较运算符

布尔类型的数据，不仅可以通过定义得到，也可以通过比较运算符进行内容比较得到

五、常用语句 

type()语句的使用方式
1.在print语句中，直接输出类型信息:

print(type(666))
print(type(11.345))
"""输出
<class 'int'>
<class 'float'>
"""

2.用变量存储type()的结果(返回值):

string_type =type("HELLO")
int_type =typě(666)
float_type = type(11.345)
print(string_type)
print(int_type)
print(float type)
"""<class 'str'>
<class 'int'>
<class 'float'>
"""

常见的转换语句

 

input语句(函数)

数据输出:print           数据输入:input

使用一个变量接收(存储)input语句获取的键盘输入数据即可

print("请告诉我你的名字")
name = input()
print("我知道了，你是:%s" %name)
# 请告诉我你是谁
# lotus
# 我知道了，你是：lotus

Tip3:无论键盘输入什么类型的数据，获取到的数据永远都是字符串类型
 

while循环语句

1.while的条件需得到布尔类型，True表示继续循环，False表示结束循环
2.需要设置循环终止的条件，如i+=1配合i<100，就能确保100次后停止，否则将无限循环
3.空格缩进和if判断一样，都需要设置

i = 1
while i <= 100:
    print(f"{i}")

for循环语句
除了while循环语句外，Python同样提供了for循环语句。两者能完成的功能基本差不多，但仍有一些区别:
·while循环的循环条件是自定义的，自行控制循环条件
for循环是一种”轮询”机制，是对一批内容进行”逐个处理”for循环语句，本质上是遍历:序列类型

#定义字符串name
name ="itheima'
# for循环处理字符串
for x in name:
print(x)

range语句

语法1:
range(num)
获取一个从0开始，到num结束的数字序列(不含num本身)
如range(5)取得的数据是:[0,1,2,3,4]

语法2:
range(num1,num2)
获得一个从num1开始，到num2结束的数字序列(不含num2本身)如，range(5,10)取得的数据是:[5,6,7,8,9]
语法3:
range(num1，num2，step)
获得一个从num1开始，到num2结束的数字序列(不含num2本身)
数字之间的步长，以step为准(step默认为1)
如，range(5,10,2)取得的数据是:[5,7,9]

continue语句

continue关键字用于:中断本次循环，直接进入下一次循环continue可以用于:for循环和while循环，效果一致

foriin range(1,100):
    语句 1
    语句 2
#在循环内，遇到continue就结束当次循环，进行下一次所以，语句2是不会执行的。

六、函数

如果将函数定义为class(类)的成员，那么函数会称之为:方法

# 函数的定义:
def 函数名(传入参数):
    函数体
    return 返回值
函数的调用:
    函数名(参数)

 传入参数的功能是在函数进行计算的时候，接受外部(调用付)提供的数据

#实现1+2相加的函数
def add():
    result=1+2
    print(f"1 + 2的结果是:{result}")

#定义实现两数相加的函数
def add(x, y):
    result=x+yprint(f"{x}+{y}的结果是:{result}")
# 调用函数
    add(5，6)

函数嵌套

#定义函数func_b
def func_b():
    print("---2---")
#定义函数func_a，并在内部调用func_b
def func_a():
    print("---1---")
#嵌套调用func_b
    func_b()
    print("---3---")
# 调用函数func_a

""" 
---1---
---2---
---3---
"""

函数多个返回值

def test return():
    return 1,2

x,y = text_return ()
print(x)   # 结果1
print(y)   # 结果2
# 按照返回值的顺序，写对应顺序的多个变量接收即可
# 变量之间用逗号隔开
# 支持不同类型的数据return

位置参数

注意:
传递的参数和定义的参数的顺序及个数必须一致

位置传递

注意:
传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是位
置传递

def user info(*args):
    print(args)
#('TOM'，)
user_info('TOM')
#('TOM'，18)
user info('TOM'，18)

关键字参数:函数调用时通过“键=值”形式传递参数
作用:可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求

注意：函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序。

关键字传递：

参数是“键=值”形式的形式的情况下，所有的“键=值”都会被kwargs接受，同时会根据“键=值”组成字典.

def user info(**kwargs):
    print(kwargs)
#'name':TOM','age':18，id':110}
user info(name='TOM',age=18,id=110)

缺省参数:缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值(注意:所有位置参数必须出现在默认参数前，包括函数定义和调用).作用:当调用函数时没有传递参数，就会使用默认是用缺省参数对应的值.

注意:
函数调用时，如果为缺省参数传值则修改默认参数值，否则使用这个默认值

不定长参数
不定长参数:不定长参数也叫可变参数，用于不确定调用的时候会传递多少个参数(不传参也可以)的场景作用:当调用函数时不确定参数个数时，可以使用不定长参数
不定长参数的类型:
①位置传递
②关键字传递

函数作为参数传递

def test_func(compute):
result=compute(1，2)
print(result)
def compute(x，y):
return x+y
test func(compute)
# 函数compute，作为参数，传入了testfunc函数中使用。
# 结果:3

test_func需要一个函数作为参数传入，这个函数需要接收2个数字进行计算，计算逻辑由这个被传入函数决定compute函数接收2个数字对其进行计算，compute函数作为参数，传递给了testfunc函数使用
最终，在test func函数内部，由传入的compute函数，完成了对数字的计算操作
所以，这是一种，计算逻辑的传递，而非数据的传递
.
就像上述代码那样，不仅仅是相加，相见、相除
等任何逻辑都可以自行定义并作为函数传入。

 None类型
如果函数没有使用return语句返回数据，那么函数有返回值是None；

Python中有一个特殊的字面量:None，其类型是:<class'WoneType)>无返回值的函数，实际上就是返回了:None这个字面量。

def say_he11o():
    print("He11o...")
#使用变量接收say_he11o函数的返回值
    result]= say_he11o()
#打印返回值
print(result)
#打印返回值类型
print(type(result))
# 结果None
#结果<class'NoneType'>

#None可以主动使用return返回，效果等同于不写return语句:
def say he1lo():
    print("He71o...")
    return None
#使用变量接收say_hel1o函数的返回值
result=say_he1lo()
#打印返回值
print(result)
# 结果None

lambda匿名函数

七、数据容器

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素每一个元素，可以是任意类型的数据，如字符串、数字、布尔等.

数据容器根据特点的不同，如:
·是否支持重复元素、是否可以修改、是否有序，等分为5类，分别是:
列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)

列表的定义:

#嵌套列表
my_1ist =[1，2，3]日[4，5，6]]
print(my_list)
print(type(my list))
# [[1，2，3]，[4，5，6]]
# <class 'list'>

1.列表的查询功能

2.修改特定位置(索引)的元素值:

3.插入元素

4.追加元素

1）语法：列表.append;

2)   语法：列表.extend；

5.删除元素

语法：列表.remove(元素）

6.清空列表：列表.clear()

7.统计元素个数：len(列表)

元组：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型

#定义3个元素的元组

t1=(1，'Hello'，True）
#定义1个元素的元组
t2=('Hello'，) #注意，必须带有逗号，否则不是元组类型

# 注意:元组只有一个数据，这个数据后面要添加逗号

元组的相关操作

字符串：无法修改的数据容器。

下标引索

字典

数据容器的通用统计功能

通用类型转换

八、文件

文件的操作步骤

① 打开文件
② 读写文件
③ 关闭文件

注意:可以只打开和关闭文件，不进行任何读写

open()打开函数

mode常用的三种基础访问模式

read 函数

for循环读取文件行

for line in open("python.txt","r"):
    print(line)
# 每一个line临时变量，就记录了文件的一行数据

close()关闭文件对象

f= open("python.txt","r")
f.close()
# 最后通过close，关闭文件对象，也就是关闭对文件的占用
# 如果不调用close,同时程序没有停止运行，那么这个文件将一直被python程序占用。

with open 语法

with open("python.txt", "r") as f:
    f.readlines()
# 通过在with open的语句块中对文件进行操作
#可以在操作完成后自动关闭close文件，避免遗忘掉close方法

九、异常

基本语法：

try:
    可能发生错误的代码
except:
    如果出现异常执行的代码

 

捕获指定的异常

try:
    print(name)
except NameError as e:
    print('name变量名称未定义错误')
# 捕获多个异常
# 当捕获多个异常时，可以把要捕获的异常类型的名字，放到except后，并使用元组的方式进行书写。
try:
    print(1/0)
except (NameError,ZeroDivisionError):
    print("ZeroDivision错误...)

十、对象

创建类对象的语法: 对象=类名称()

成员变量和成员方法（函数）

self关键字是成员方法定义的时候，必须填写的。

class student:
    name =None #学生的姓名
    age = None #学生的年龄
    def say hi(self):
        print(f"Hi大家好，我是{self.name}")
#self关键字是成员方法定义的时候，必须填写的。

# 设计一个闹钟类
class Clock:
    id = None #序列化
    price = None #价格

    def ring(self):
        import winsound
        winsound.Beep(2000，3000)
#构建2个闹钟对象并让其工作
clock1=Clock()
clock1.id ="003032"
print(f"闹钟ID:{clock1.id}，价格:{clock1.price}")
clock1.ring()

Python类可以使用:_init()方法，称之为构造方法。

在创建类对象(构造类)的时候，会自动执行。
在创建类对象(构造类)的时候，将传入参数自动传递给init方法使用。

class student:
    name = None
    age = None
    tel = None
    definit_(self,name,age,tel):
        self.name =name
        self.age = age
        print("student")
stu=student("周杰轮”，31,"18500006666")

内置方法（魔术方法）

1._init_ 构造方法    2._str_字符串方法  3._it_ 小于、大于符号比较

4._le_小于等于、大于等于符号比较  5._eq_=符号比较

面向对象的三大特性

封装 继承 多态

私有成员

私有成员变量:变量名以开头(2个下划线)

私有成员方法:方法名以开头(2个下划线)

私有成员无法被类对象使用，但是可以被其它的成员使用。

class Phone:
    ——current voltage =0.5 #当前手机运行电压
    def _keep_single_core(self):
        print("让CPU以单核模式运行”)
    def ca11 by_5g(se1f):
        if self. current_voltage >=1:
            print("5g通话已开启")
        else:
            self._keep_single_core()
            print("电量不足，无法使用5g通话，并已设置为单核运行进行省电。")

继承

单继承

多继承

多个父类中，如果有同名的成员，那么默认以继承顺序(从左到右)为优先级。

class Phone:IMEI= None#序列号
    producer = None#厂商
    def ca11_by_5g(se1f):
        print("5g通话”)
class NFCReader:
    nfc_type =“第五代"
    producer = "HM"
    def read_card(self):
        print("该取NFC卡")
    def write_card(self):
        print("写入NFC卡")
class Remotecontrol:
    rc_type ="红外通控”
    def control(self):
        print("红外暹控开启")
c1ass MyPhone(phone, NFcReader, Remotecontro]):
    pass

复写：:在子类中重新定义同名的属性或方法即可，

调用父类同名成员

方法1:
·调用父类成员
使用成员变量:父类名,成员变量
使用成员方法:父类名.成员方法(self)
方式2:
使用super()调用父类成员
使用成员变量:super().成员变量
使用成员方法:super().成员方法()

Union 类型

使用Union[类型,…, 类型]，可以定义联合类型注解

多态

多态，指的是:多种状态，即完成某个行为时，使用不同的对象会得到不同的状态