变量
Python 变量声明时不需要定义变量的类型,直接定义变量名,然后赋值即可使用。
message = "Hello World!"
x, y, z = 0, 1, 2
在定义变量时,需要满足如下的命名要求:
- 变量名只能包含字母、数字和下划线。变量名能以字母或下划线开头,但不能以数字开头;
- 变量命不能包含空格;
- 不能使用 Python 的关键字作为变量名。
定义的变量名,最好能够满足:
- 变量名尽量简洁和具有描述性;
- 尽量避免使用小写字母 l 和大写字母 O,因为这两个字母和数字 1 和 0 很像;
- 变量名建议全部小写,使用下划线分隔。
字符串
字符串就是一系列字符。在 Python 中使用引号括起来的都是字符串。引号可以是单引号或者双引号。
str1 = "This is a string."
str2 = 'This is a string too.'
单引号和双引号可以搭配使用,运行在复合场景下:
str1 = "I'm a student."
str2 = 'I like this "dog"'
在字符串中使用变量,在 f
字符串格式化下使用 {}
占位符:
first_name = "Zhang"
last_name = "San"
full_name = f"{first_name}{last_name}"
format_name = f"{full_name}.title()"
字符串常见的方法:
方法 | 作用 | 示例 | 输出结果 |
---|---|---|---|
upper() | 转大写 | ‘hello world’.upper() | HELLO WORLD |
lower() | 转小写 | ‘HELLO WORLD’.lower() | hello world |
title() | 英文单词,首字母大写 | ‘hello world’.title() | Hello World |
rstrip() | 删除右边空格 | ’ python '.rstrip() | <空格>python |
lstrip() | 删除左边空格 | ’ python '.lstrip() | python<空格> |
strip() | 删除左右两边空格 | ’ python '.strip() | python |
整数和浮点数
不带小数点的数是整数 ,带小数点的数是浮点数。对于很大数字 ,可以使用下划线分隔,方便阅读(类似会计计数法)。
big_number = 13_000_000_000
数学算术符
算术运算 | 符号 | 示例 | 输出结果 |
---|---|---|---|
加 | + | 1+2 | 3 |
减 | - | 3-1 | 2 |
乘 | * | 4*8 | 32 |
除 | / | 4/2 | 2 |
乘方 | ** | 2**10 | 1024 |
模(余数) | % | 4 % 3 | 1 |
请注意:
- 任意两个数字相除时,结果总是浮点数,即使这两个数是整数且能整除;
- 任意运算中,只要有一个操作数是浮点数,结果总是浮点数。
>>> 4/2
2.0
>>> 1 + 2.0
3.0
数学函数
函数 | 含义 | 示例 | 输出结果 |
---|---|---|---|
min() | 求最小值 | min([1,2,3,4,5,6,7]) | 1 |
max() | 求最大值 | max([1,2,3,4,5,6,7]) | 7 |
sum() | 求和 | sum([1,2,3,4,5,6,7]) | 28 |
注释
使用 #
进行注释:
# 请说大家好
print("Hello everyone!")
使用 """
定义文档字符串的注释,通常用于描述函数是做什么的,Python 将其生成到相关程序文档中。
def print_name(name):
"""打印姓名"""
print(name)
列表
列表由一系列按特定顺序排序排列的元素组成,所以列表是有序集合。列表用方括号([ ])表示,使用逗号进行分隔。
bicycles = ['trek', 'cannondale', 'redline', 'spcialized', 'merida']
访问元素
列表的下标索引从 0 开始,通过使用 [索引]
的方式访问列表的元素:
print(bicycles[0]) #trek
print(bicycles[1]) #cannondale
使用负数索引来倒序访问列表元素:
print(bicycles[-1]) #spcialized
print(bicycles[-2]) #redline
删除元素
删除列表中元素方法有三种:
- del 删除指定索引的元素;
- pop 删除列表末尾的元素或指定索引的元素;
- remove 删除指定某个值的元素。
del bicycles[0]
del bicycles[1]
bicycles.pop()
bicycles.pop(0)
bicycles.remove('merida')
remove 删除元素只删除第一次遇到的元素,若列表中有多个值,则需要使用循环的方式删除。
修改元素
通过索引的方式修改列表的值:
cars = ['BWM', 'BYD', 'Audi', 'Honda']
cars[0]='Hummer'
添加元素
末尾追加元素使用 append()
,任意位置添加使用 insert()
:
cars.append('Jeep')
cars.insert(0, 'Kia')
列表排序
使用 sort
进行永久排序,使用 sorted
进行临时排序:
cars.sort() #正序
cars.sort(reverse=True) #倒序
使用 reverse
让列表倒序:
cars.reverse()
列表长度
使用 len()
获取列表的长度:
len(cars)
遍历列表
使用 for-in 遍历列表:
for car in cars:
print(car)
数值列表
使用 range()
函数创建生成一系列数,然后通过 list()
函数将 range()
函数的结果转换成列表。
for value in range(1,10)
print(value) # 1 2 3 4 5 6 7 8 9 10
for value in range(1,10,2)
print(value) # 1 3 5 7 9
numbers = list(range(1,10)) # [1,2,3,4,5,6,7,8,9,10]
列表解析是将 for 循环和创建新元素的代码合并成为一行,并自动附加新元素:
squares=[value**2 for value in range(1,10)]
切片
列表中的部分元素成为切片。切片使用冒号(:)进行衔接元素:
players = ['Ming', 'Hong', 'San', 'Si', 'Hua']
print(players[0:2]) # Ming Hong San
print(players[:1]) # Ming Hong
print(players[3:]) # Si Hua
print(players[-1]) # Hua
print(players[-2:]) # Si Hua
可以使用 for-in 循环遍历切片:
for player in players:
print(player)
想要复制切片可以使用 [:]
语法:
new_players = players[:] # 创建了一个 players 的副本
元组
列表是可变的,想要创建不可变的列表,可以使用元组。元组使用圆括号 ( )
定义,通过索引访问元组中的元素。
phones = ('Vivo', 'Xiaomi', 'Huawei', 'iPhone')
print(phones[0])
for phone in phones:
print(phone)
字典
字典是一系列键值对。每个键都与一个值对应。字典使用花括号({ })定义,键与值之间使用冒号进行分隔,键值对之间使用逗号分隔。
student = ('first_name':'San', 'last_name':'Zhang')
student_scores = ('first_name':'San', 'last_name':'Zhang', 'scores':[90, 89, 95, 89]) # 值是列表
student_info = ('first_name':'San', 'last_name':'Zhang', 'info': {'age':'20', 'english': 98}) # 值是字典
访问、修改和删除
通过使用 [键]
的方式,访问字典的值或者修改字典的值:
print(student['first_name'])
student['first_name'] = 'Li'
删除字典的键值对使用 del 方法:
del student['first_name']
通过 [键]
的方式访问字典存在一个弊端:如果指定的键不存在,则会报错。为了避免报错,可以使用 get() 方法指定当键不存在时返回的默认值:
student.get('gender', 'male')
新增键值对
想要新增键值对,可以采用如下的方式:
student['age'] = 20
有时候,可以先创建一个空字典,必要时在添加键值对:
book={}
book['name'] = 'Romeo and Juliet'
遍历字典
遍历字典所有键值对使用 items()
方法,遍历所有键使用 keys()
方法,遍历所有值使用 values()
方法。
user = {
'username': 'san.zhang',
'password': '123456789',
'last_login' : '2024-02-24 09:45:00'
}
# 遍历键值对
for key, value in user.items():
print(f'key={key},value={value}}')
# 遍历所有的键
for key in user.keys():
print(f'key={key}')
# 遍历所有的值
for value in user.values():
print(f'value={value}')
选择结构
条件测试
一个语句要么返回 True,要么返回 False,这个语句就是条件测试语句,也称为布尔表达式。
条件测试 | 含义 | 示例 | 输出结果 |
---|---|---|---|
== | 相等 | 1 == 2 | False |
!= | 不相等 | 1 != 2 | True |
> | 大于 | 1 > 2 | False |
< | 小于 | 1 < 2 | True |
>= | 大于等于 | 1 >= 2 | False |
<= | 小于等于 | 1 <= 2 | True |
in | 判断元素是否在列表中 | 1 in [1,2,3,4,5] | True |
not in | 判断元素不在列表中 | 1 not in [1,2,3,4,5] | False |
当多个条件组合时,可以使用 and 或者 or 连接两个条件测试语句:
条件测试 | 含义 | 示例 | 输出结果 |
---|---|---|---|
and | 并且 | 1 != 2 and 2 !=3 | True |
or | 或者 | 1 > 2 or 2 < 3 | False |
if-elif-else
选择结构有三种形式:
- 只有一个 if 构成的选择结构;
- if-else 组成选择结构;
- if-elif-else 组成的复合选择结构,其中 elif 可以不限个数。复合结构下,else 可以根据情况省略。
age = 19
# 只有一个 if 构成的选择结构
if age < 18
print('未成年')
# if-else 组成选择结构
if age < 18
print('未成年')
else
print('成年人')
# if-elif-else 组成的复合选择结构
if age < 1
print('婴儿')
elif age < 19
print('青少年')
elif age < 30
print('青壮年')
elif age < 60
print('中年人')
else # 根据情况可以省略
print('老年人')
if 可以判空列表
当列表元素个数为 0 时,我们称之为空列表。使用 if 语句可以判断列表是否为空:
users=[]
if users:
print('The list of user is empty.')
else:
print(users)
后续提到的 while 循环同样也可以判断列表。
循环结构
循环结构有两种:for-in 循环和 while 循环。for-in 循环需要搭配列表或者字典等场景使用,而 while 循环相对独立一些。while 循环会不断运行,直到条件不满足为止。
count = 0
while count <= 10 # 只要满足这个条件,就会不断执行
print(count)
count += 1
退出循环可以使用 break,停止本次循环接续下一次循环可以使用 continue:
count = 0
while count <= 10
if count in [1,3,5,7]
continue # 当 count 为 1 3 5 7 时,跳过后面语句,执行下一次循环
if count == 9
break # 当 count 等于 9 时,提前结束循环
在使用 for-in 循环时,不应当修改列表或者字典的元素,否则会导致 Python 难以跟踪其中的元素。想要一边遍历,一边操作元素可以使用 while 循环。
users = ['Alice', 'Bob', 'Duo']
confirmed_users = []
while users:
print(users)
user = users.pop()
print(f'Popped this user {user} from users.')
confirmed_users.append(user)
print(f'confirmed users: {confirmed_users }')
用户输入
获取终端用户的输入的字符串使用 input()
方法。
message = input('Tell me something, and I will repeat it back to you: ')
print(message)
# 因为 input 读取到的始终是一个字符串,因此需要使用 int() 函数将字符串转换成数值
age = input('Your age: ')
age = int(age)
if age < 18:
print('未成年')
else
print('成年人')
函数
函数是带名字的代码块,使用 def 关键字定义一个函数,使用圆括号定义函数接收的参数。
# 定义函数
def greet_user():
print("Hello!")
# 调用函数
greet_user()
形参与实参
函数定义的参数称为形式参数(形参),调用函数传递的参数称为实际参数(实参)。在函数定义时,可以先定义形式参数。
def greet_user(name):
print(f'Hello, {name}!')
greet_user('Li Hua')
根据参数的位置可以将实参分成:位置实参和关键字实参。位置实参要求实参与形参的顺序相同:
def greet_user(first_name, last_name):
print(f"Your name is {first_name} {last_name}")
greet_user('San', 'Zhang')
关键字实参通过让参数名与值关联,所以可以让实参与形参的顺序不同:
def greet_user(first_name, last_name):
print(f"Your name is {first_name} {last_name}")
greet_user(first_name = 'San', last_name = 'Zhang')
greet_user(last_name = 'Zhang',first_name = 'San')
参数默认值
在定义形参时,可以为形参设置一个默认值,调用时可以传可不传:
def greet_user(first_name, last_name, school = 'No.2 Middle School'):
print(f"Your name is {first_name} {last_name} and your school is {school }")
greet_user('San', 'Zhang', 'No.1 Middle School')
greet_user('Si', 'Li')
函数返回值
在函数中,使用 return 语句让函数返回某个值。
def full_name(first_name, last_name):
return f'{first_name} {last_name}'
full_name = full_name('San', 'Zhang')
print(full_name)
引用参数传递
函数的形式参数为列表、字典等时,传递的方式为引用传递。
def modify(numbers):
numbers.append(4) # 在函数内部修改列表
numbers= [1, 2, 3]
modify(numbers)
print(numbers) # 输出 [1, 2, 3, 4]
通过使用切片的方式,可以实现不改变实参的列表元素:
def modify(numbers[:]):
numbers.append(4) # 在函数内部修改列表
numbers= [1, 2, 3]
modify(numbers)
print(numbers) # 输出 [1, 2, 3]
任意参数
无法确认参数个数时,可以使用任意参数。使用 *
表示元组,使用 **
表示字典。
def print_number(*numbers):
print(numbers)
print_number(1)
print_number(1, 2)
print_number(1, 2, 3)
print_number(1, 2, 3, 4)
print_number(1, 2, 3, 4, 5)
def print_name(**names):
print(names)
print_name(first_name = 'San', last_name = 'Zhang')
元组中的元素不可修改。
导入外部依赖
在一个文件中引入另外一个模块的函数,有三种导入方法:
- 导入整个模块;
- 导入模块中的所有函数和变量;
- 导入模块中的某个函数或变量;
# 导入整个模块
import module_name
# 导入模块中的所有函数和变量
from module_name import *
# 导入模块中的某个函数或变量
from module_name import function_name, variable_name
第 1 种方式和第 2 种方式的区别在于:第 1 种方式在调用导入模块的函数时,需要使用 模块名.函数名
的方式调用函数。而第 2 种方式直接使用函数名调用。因此,第 1 种方式可以避免函数名重复定义,第 2 种则无法避免(污染了当前环境)。因此,推荐使用第 1 种方式导入函数。
导入后的函数或者模块,可以通过 as 关键字设置别名:
import module_name as a
from module_name import * as b
类
现实世界的对象可以抽象成类。类使用 class 关键字定义,类由属性、方法(在类中称函数为方法)构成。类的命名使用驼峰命名法。
class Dog:
def __init__(self, name, age):
self.name = name
self.age = age
def set_age(self, age):
self.age = age
def site(self):
print(f'{self.name} is now sitting')
def roll_over(self):
print(f'{self.name} rolled over!')
__init__()
是类的构造方法,所有实例化对象时都会调用该方法。形参 self
必不可少,且必须位于所有参数前面。这是因为 Python 在实例化对象时,会自动传入 self
参数。self
参数是一个指向实例本身的引用,让实例可以访问到类中的属性和方法。name
和 age
是类中的属性,通过 self
参数获取该属性值。site()
和 roll_over()
称为方法。
当类创建完成后,实例化出该类的对象,然后调用对象的方法:
my_dog = Dog('小黑', 2)
my_dog.site()
my_dog.roll_over()
your_dog = Dog('小白', 1)
your_dog .site()
your_dog .roll_over()
属性值
在构造方法中可以给类的属性值设置默认值。
class Dog:
def __init__(self, name, age):
self.name = name
self.age = age
self.color = 'Black'
def set_age(self, age):
self.age = age
def site(self):
print(f'{self.name} is now sitting')
def roll_over(self):
print(f'{self.name} rolled over!')
my_dog = Dog('小黑', 2)
my_dog.age = 3 # 修改属性值
my_dog.set_age(4) # 通过方法修改属性值
继承
一个类继承另外一个类时,将自动获取到另外一个类的所有属性和方法。原生的类成为父类,新的类成为子类。子类可以定义自己的属性和方法。在继承时,子类创建前需要创建父类。通常,在子类的构造方法中需要调用父类的构造方法。
class Car:
def __init__(self, color, brand):
self.color = color
self.brand = brand
def drive(self, driver_name):
print(f'{driver_name} is driving a {self.brand} car.')
class ElectricCar(Car): # 继承父类
def __init__(self, color, brand):
super().__init__(color, brand) # 调用父类的构造函数
def drive(self, driver_name): # 重写父类的函数
print(f'{driver_name} is driving a {self.color} {self.brand} car. And this car is a eletric car.')
car = ElectricCar('White', 'Tesla')
car.drive('Bob')
文件操作
打开文件使用 open()
函数,关闭文件使用 close()
函数,读文件使用 read()
、 readline()
和 readlines()
函数,写文件使用 write()
函数或者 writelines()
,自动关闭文件使用 with-as
语句。
# 只读模式打开文件
file = open('a.txt', 'r')
# 写模式打开文件(若文件不存在,则会自动创建)
file = open('a.txt', 'w')
# 追加模式打开文件(若文件不存在,则会自动创建)
file = open('a.txt', 'a')
# 读整个文件
content = file.read()
# 读一行
line = file.readline()
# 读取所有行并存储到列表中
lines = file.readlines()
# 写入字符串到文件
file.write('Hello, World!')
# 写入多行字符串到文件
lines = ['Line 1\n', 'Line 2\n', 'Line 3\n']
file.writelines(lines)
# 关闭文件
file.close()
# 自动关闭文件
# 在 with 代码块结束时,文件会自动关闭,无需手动调用 file.close()
with open('a.txt', 'r') as file
print(file.read())
JSON 文件处理
导入 json 模块后,可以处理 json 格式的文件。使用 json.dump() 保存一个 json 文件到本地磁盘,使用 json.load() 读取一个 json 文件。
import json
numbers = [1, 2, 3, 4, 5]
filename = 'numbers.json'
with open(filename, 'w') as wf:
json.dump(numbers, wf)
with open(filename, 'r') as rf
new_numbers = json.load(rf)
print(new_numbers)
异常处理
程序运行发生的错误称为异常。异常的处理使用 try-except-else
语句处理。其中,else 语句可以省略。
try:
with open('a.txt', 'r') as f:
contents = f.read()
except:
print("Read failed.")
else:
print("Read successful.")
当异常发生时,也可以不做任何处理,这种行为称为静默失败。静默失败使用 pass 关键字标记。
try:
with open('a.txt', 'r') as f:
contents = f.read()
except:
pass # 静默失败
else:
print("Read successful.")
None
None
是一个特殊的类型,表示空值或者缺失值。None
通常用于表示一个变量没有被赋予任何值。使用 None
可以更好地处理变量赋值和状态判断。
# 可以直接将变量赋值为 None。赋值为 None 的变量会被清空变量的内容,释放内存并标记为未使用。
x = None
# 检查是否为 None,可以使用 is 关键字
if x is None:
print('X is a None.')
else:
print(x)
# 如果函数没有明确返回任何值,则默认返回 None。
def greet_user:
return None
单元测试
单元测试用于测试某个函数不存在问题。通过导入 unittest 模式,测试类继承 unittest.TestCase
来执行单元测试。
import unittest
def add(a, b):
return a + b
class CalculatorTest(unittest.TestCase): # 继承测试类
def test_add(self): # 测试方法
self.assertEqual(add(1, 2), 3)
if __name__ == '__main__':
unittest.main()
断言方法
判断程序运行的结果是否与期待的结果相等,称之为断言。
方法 | 含义 | 示例 | 输出结果 |
---|---|---|---|
assertEqual(a, b) | 判断是否相等 | assertEqual(1, 2) | False |
assertNotEqual(a, b) | 判断是否不相等 | assertNotEqual(1, 2) | True |
assertTrue(x) | 判断是否为 True | assertTrue(1 == 2) | False |
assertFalse(x) | 判断是否为 False | assertFalse(1 == 2) | True |
assertIn(item, list) | 判断元素是否在列表中 | assertIn(3, [1, 2, 3 , 4]) | True |
assertNotIn(item, list) | 判断元素是否不在列表中 | assertNotIn(3, [1, 2, 3, 4]) | False |
setUp 和 tearDown
unittest
支持在每个测试方法执行前后执行一些准备和清理操作,可以使用 setUp
和 tearDown
方法。
class TestStringMethods(unittest.TestCase):
def setUp(self):
# 在每个测试方法执行前调用
pass
def tearDown(self):
# 在每个测试方法执行后调用
pass
以上就是“Python 简明教程”的全部内容,希望对你有所帮助。
关于Python技术储备
学好 Python 不论是就业还是做副业赚钱都不错,但要学会 Python 还是要有一个学习规划。最后大家分享一份全套的 Python 学习资料,给那些想学习 Python 的小伙伴们一点帮助!
一、Python所有方向的学习路线
Python所有方向的技术点做的整理,形成各个领域的知识点汇总,它的用处就在于,你可以按照上面的知识点去找对应的学习资源,保证自己学得较为全面。
二、Python必备开发工具
三、Python视频合集
观看零基础学习视频,看视频学习是最快捷也是最有效果的方式,跟着视频中老师的思路,从基础到深入,还是很容易入门的。
四、实战案例
光学理论是没用的,要学会跟着一起敲,要动手实操,才能将自己的所学运用到实际当中去,这时候可以搞点实战案例来学习。
五、Python练习题
检查学习结果。
六、面试资料
我们学习Python必然是为了找到高薪的工作,下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料,并且有阿里大佬给出了权威的解答,刷完这一套面试资料相信大家都能找到满意的工作。
最后祝大家天天进步!!
上面这份完整版的Python全套学习资料已经上传至CSDN官方,朋友如果需要可以直接微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】。