快速入门Python（有其他语言基础）
通过本文章的学习，有其他语言基础的可以快速入门掌握Python
学习建议：内容已经极度精简，代码块里的内容要掌握好，在学习期间，要注意与其他语言的区别，例如在python中，区分是否为同一个代码块是通过空格来实现。
每一种python语法，通过所举例子的学习，基本能够掌握，重视对例子的理解！
祝各位彦祖学习愉快！
目录
入门
python
print("hello world")
# print("hello world" + 666)这是错误的，python不允许将整数和字符串进行拼接
# 这是一个单行注释
"""
这是多行注释
重新学习python
"""变量 (变量无类型)
python
money = 100
print("钱包还有:", money)
#这里和java就有不同的了,print(内容1, 内容2, 内容3....)
#ctrl + d 是复制当前行到下一行
money -= 10
print(money)数据类型与数据类型转换
python
# 用type()函数查看数据的类型
print(type(money))
string_type = "string"
print(string_type)
print(type(string_type))
"""
type类型的返回值是string
变量无类型，其存储的数据有类型，type(变量)查看的是变量存储的数据的类型
所以如下代码能够成功运行：
money = "100"
print(money) # 100
print(type(money)) # str
"""
"""
转换类型 函数：int() str() float()
"""
count = 260075
print("最开始count的类型是：", type(count))
count = str(count)
print("现在的count的类型是：", type(count))
count = 1.511
print(count)
count = int(count)
print(count)# 仍然采取截断的方式，丢失精度并且回转回float的时候丢失精度
count = float(count)
print(count)标识符
python
# 标识符 字母数字下划线 中文-不推荐
名字 = "吴彦祖"
#多个单词组合变量名，用下划线进行分隔|||java一般驼峰命名
first_name = 名字运算符
python
"""
+ - * /
// 取整除：9//2 = 4 9.0//2.0 = 4.0 # java:1/2 = 0,本身即为整除
** 指数：a**b为a的b次方
"""
a = 2
b = 3
print("a ** b的结果是：", a ** b) # ANS 8
print("a/b的结果是", a / b)
print("a//b的结果是", a // b)字符串扩展
python
# 字符串扩展
"""
三种定义方式 单引号，双引号，三引号
其中三引号定义法 使用变量接收-则为字符串，不使用则作为多行注释使用
引号可以嵌套，使用转义符\\ 或者 多引号中嵌套少一个引号的对应引号
"""
name1 = '我是一名\"工程师\" '
name2 = "我是一名'工程师2' "
name3 = """我是一名"工程师3" """
name4 = """我是一名'工程师'"""
print(name1, name2, name3, name4)
print("我的名字是吴彦祖" + name1)#字符串可以进行拼接
print("我的名字是吴彦祖", name1)
age = 22
print("我的年龄是" + str(age))
==============================================================================
# 字符串格式化
message = "我的名字是吴彦祖,我的年龄是：%d," % age + name1
print(message)
message2 = "特别提醒我的年龄是%d,再重复一遍刚才的话:%s" % (age, message)
print(message2)
pi = 3.1415926
print("pi的值是%5.3f" % pi)#数据精度控制会有四舍五入,m.n其中m是数据的宽度，即整数和小数总位数，不够则加空格,当m必数字本身宽度还小，则m不生效
print("pi的值是%10.3f" % pi)
"""
字符串格式化2
通过语法：f"内容{变量}" 的格式来快速格式化 不做精度控制 常用于拼接字符串
"""
print(f"我的名字是吴彦祖，{name1},我的年龄是{age},我知道pi的值是：{pi}")
# 表达式(有具体结果)进行格式化
print(f"我知道3pi的结果是{pi * 3}")
================================================================================
# 数据输入
name = input("请告诉我你是谁?")#input返回的是string类型
print(f"我知道了你是{name},刚才你输入我接受的数据类型为(class里面的东西才是，本身type返回的是str){type(name)}")判断语句
python
bool_1 = "吴彦祖" == name
print("吴彦祖是你吗？", bool_1)
if bool_1:
print("你是吴彦祖，你帅的要命")#前面有四个空格缩进
print("你已经是一名工程师了")
elif name == "好朋友":
print("你是主人的好朋友，祝你生活快乐")
elif int(input("请告诉我你的年龄")) == age:
print("恭喜你，你是主人的同龄人，是%d岁" %age)
else:
print("你不是我的主人，赶快离开")
print("你不是我的主人，赶快离开")
print("你不是我的主人，赶快离开")
# 在python中，是通过空格缩进来决定语句之间的层级关系
print("时间过的真快呀！")循环语句
while
python
#while 循环条件自定义，自行控制循环条件
#猜数字
import random
i = random.randint(1, 100)
flag = True
while flag:
yourCount = int(input("请输入你猜的数字") )
if yourCount == i:
flag = False
elif yourCount > i:
print("你猜的数字大了")
else:
print("你猜的数字小了")
print("恭喜你猜对了,", end="")
print("你真是一个聪明鬼！")
# =========================================================
#打印九九乘法表
i = 1
while i <= 9:
j = 1
while j <= i:
print(f"{j} * {i} = {j*i}\t", end="")
j = j + 1
i = i + 1
print()for
python
"""
for 轮询机制，对一批内容进行逐个处理，无法自定义循环条件
其中待处理数据集，严格来说，称之为：序列类型
序列类型指，其内容可以一个个依次取出的一种类型，包括：
字符串
列表
元组
for 临时变量 in 待处理数据集
临时循环满足条件时执行的代码
"""
name = "i im wuyanzu"
i = 0
for c in name:
if(c == "a"):
i += 1
print(f"{name}中共含有：{i}个字母a")
"""
for本质遍历的是序列类型range(range 是序列类型中的一个 为不可变的整数序列类型)
#range语句 3种语法
1.range(num) 获取一个从0开始，到num结束的数字序列(不含num本身)
range(5) is [0,1,2,3,4] range返回值类型为range
2.range(num1, num2) 获取从num1开始，到num2结束的数字序列 左闭右开
3.range(num1, num2, step) 获取一个从num1开始，到num2结束的数字序列，数字间步长为step
range(5, 10, 2) is [5, 7, 9]
"""
#通过range快速确定循环次数
for x in range(10):
print(f"送玫瑰花，第{x+1}朵")函数
函数基础
python
#函数定义 先定义，后调用
def 函数名(传入参数):
函数提交
return 返回值在python中，如果函数没有使用return语句返回数据，那么函数的返回值为None(特殊的字面量) 其类型为：<class 'NoneType'>
None => False
None还可用于声明无初始内容的变量
global关键字在函数内使用，声明当前变量为全局变量
python
num1 = 100#全局变量
print(num1)
def say():
"""
用于试验python的函数功能
:return: 返回一个返回值
"""
#num1 = 222#在函数内声明的为函数内的局部变量
global num1#在函数内声明num1是全局变量
num1 = num1 + 1
print(num1)
print("欢迎来到我的世界")
return "这句话是返回值"
print(say())
python
money = 5000000
name = None
def inquireMoney():
global money
print("==========查询余额==========")
print(f"{name}，您好，您的余额剩余：{money}元")
def decreaseMoney(count):
print("==========取款==========")
global money
money -= count
print(f"{name}，您好，您取款{count}元成功")
print(f"{name}，您好，您的账户剩余{money}元")
def addMoney(count):
print("==========存款==========")
global money
money += count
print(f"{name}，您好，您存款{count}元成功")
print(f"{name}，您好，您的账户剩余{money}元")
def main():
global name
while True:
print("==========主菜单==========")
print(f"{name}您好，欢迎来到曦煜银行，请选择操作:")
print("查询余额\t[输入1]")
print("存款\t\t[输入2]")
print("取款\t\t[输入3]")
print("退出\t\t[输入4]")
op = input("请输入您的选择:")
if op == "1":
inquireMoney()
elif op == "2":
count = int(input("请输入存款数额"))
addMoney(count)
elif op == "3":
count = int(input("请输入取款数额"))
decreaseMoney(count)
else:
break
print("感谢您的使用，祝您生活愉快")
name = input("请输入你的姓名")
main()函数多返回值
python
def test_return():
return 1, 2
x, y = test_return()
按照返回值顺序，对应接收函数参数种类
python
1.位置参数
调用函数时，根据函数定义的参数位置来传递参数
============================================================================================
2.关键字参数
通过"键=值"形式传递参数
function：清楚参数顺序要求
def user_info(name, age, gender):
print(f"您的名字是{name},您的年龄是{age},您的性别是{gender}")
user_info("彦祖", gender= "男", age= 22)#可以和位置参数混用，位置参数必须在前，且匹配参数顺序
============================================================================================
3.缺省参数
默认值放最后
def user_info(name, age, gender = '男'):
print(f"您的名字是{name},您的年龄是{age},您的性别是{gender}")
user_info("彦祖", age= 22)
============================================================================================
4.可变参数(不定长参数)
<1>位置不定长
def user_info(*args):#args 为元组类型
print(args)
user_info("彦祖", 22)
<2>关键字不定长
def user_info(**kwargs):#kwargs 为字典类型,参数形式为"key=value"
print(kwargs)
# user_info("姓名"="彦祖", "年龄"=22)#报错,应为变量=value
user_info(name="彦祖", age=22)#当key不为不可变数据容器类型时，会将在字典中存储的key为'key'，name="彦祖"即key为:'name'
my_tuple = (1, 2, 3)
my_dict = {my_tuple:1}
#不可变数据类型可以作为key
print(my_dict)函数作为参数传递
python
def test_func(add):
res = add(1, 2)
print(res)
def my_add(a, b):
return a + b
test_func(my_add)lambda匿名函数
python
lambda 传入参数:函数体(一行代码)
def test_func(add):
res = add(1, 2)
print(res)
test_func(lambda x, y: x + y)Python数据容器
list(列表)
定义：
变量名称 = [元素1, 元素2, 元素3...] 空列表： 变量名称 = list()
列表中可以存储不同的数据类型
下标索引可以从后往前，分别为-1，-2，-3...
常用操作：
python
列表.index(元素) : 查询指定元素在列表的下标，找不到就报错ValueError
列表[下标] = 值 : 改值
列表.insert(下标, 元素):在指定下标插入元素
列表.append(元素):追加元素
列表.extend(其他数据容器) : 将其他数据容器的内容去除，一次追加到列表尾部
删除：
del 列表[下标]
列表.pop(下标) #下标为空时，pop列表末尾
列表.remove(元素) ：删除元素在列表中的第一个匹配项
列表.clear()
列表.count(元素) ： 元素在列表内的数量
len()函数：计算容器中项目的个数tuple(元组)
元组一旦定义完成，就不可修改(可以修改元组内list内容),数据可以是不同是数据类型
和list共同点：有序，较大元素数量，允许重复元素
定义：变量名称 = (e1, e2, e3)
注意，只有一个数据时，数据后要加逗号 my_tuple = (e1,) ,否则类型是str
python
index(元素)
count(元素)
len(元组)str（字符串）
字符串支持下标索引 不可修改
my_str="wuyanzu"
python
字符串.index(元素)
字符串.replace(字符串1， 字符串2) ： 将字符串中的全部字符串1换为字符串2 （得到新字符串，原字符串不会改动）
字符串.split(分隔符字符串) ： 按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中 (字符串本身不变，而是得到了一个列表对象)
字符串.strip() : 字符串规整操作（去前后空格）
字符串.strip(字符串) ： 字符串规整操作（去前后指定字符串）
my_str = "12asdfgjkl21"
print(my_str.strip("12")) => "asdfgjkl" #按照的是单个字符进行规整 返回字符串
字符串.count(字符串)
len(字符串)序列(一类数据容器) | 切片
内容连续，有序，可使用下表索引的一类数据容器：列表，元组，字符串等
切片：从一个序列中，取出一个子序列
语法：序列[起始下标:结束下标:步长] : 从序列中，起始下标开始，依次取出元素，到指定位置结束，得到一个新序列：
起始下标：可以留空，表示从头开始
结束下标：可以留空，表示到结尾
步长：1 表示一个个取元素，2 表示跳过1个元素取
对序列进行切片操作，不会影响序列本身，而是会得到一个新的序列
python
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(my_list[:4])#[1, 2, 3, 4]
my_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9)
print(my_tuple[::1])#(1, 2, 3, ... , 9)
my_str = "123456789"
print(my_str[::2])#"13579"
print(my_str[::-1])#"987654321"
print(my_str[3:1:-1])#"4, 3"
print(my_str[1:3:-1])#""
print(my_tuple[::-2])#(9, 7 , 5, 3, 1)
#方法一般左闭右开 但如果是空着的，就是从头到尾整个序列set（集合）
无序，不可重复,无法下标索引访问,允许修改
变量名称 = {元素, 元素....}
set()空集合
python
set.add(e)
set.remove(e)
set.pop() # 随机弹出一个元素
set.clear()
集合1.difference(集合2) # 取出集合1和集合2的差集 1有2无的 得到新集合，原集合不变机
集合1.difference_update(集合2) # 在集合1中删除和集合2相同的元素， 集合1被修改，2不变
set1.union(set2) # 返回新集合：set1和set2交集
# 只能通过for遍历dict（字典）
键值对：key->value
虽然python的dict无序，但是在较新版本中会保留插入循序
key不允许重复，重复添加等同于覆盖原有数据
key和value value可以为任意数据类型，但是key不能为dict,list等可变类型，可以为tuple，str等不可变的容器类型
python
空集合: {} dict()
my_dict = {key1: value1, key2: value2, key3: value3}
my_dict[key1] #得到value1
删除元素：my_dict.pop(key)
清空：my_dict.clear()
获取全部key：my_dict.keys()
字典的遍历：
1. for key in my_dict.keys():
print(my_dict[key])
2. for key in my_dict:
print(my_dict[key])
两种循环key相同
value = my_dict[key] # 是地址传递,改变value会改变字典对应key的值
python
# 练习-理解如下代码
my_dict = {"王力宏":
{
"部门": "科技部",
"工资": 3000,
"级别": 1
},
"周杰伦":
{
"部门": "市场部",
"工资": 5000,
"级别": 2
},
"林俊杰":
{
"部门": "市场部",
"工资": 7000,
"级别": 3
},
"张学友":
{
"部门": "科技部",
"工资": 4000,
"级别": 1
},
"刘德华":
{
"部门": "市场部",
"工资": 6000,
"级别": 2
},
}
print(my_dict)
flag = 0
for key in my_dict:
flag += 1
value = my_dict[key]
if value["级别"] == 1:
value["级别"] += 1
value["工资"] += 1000
if flag % 2 == 0:
print(f"{key}: {value}")
else:
print(f"{key}: {value}",end="")数据容器的通用方法
python
len(container)
max(container) # 字典使用时，只关心key
min(container)
sorted(container, [reverse = True])) # 返回值为list
list(container) # 字典转列表，只保留key
tuple(container) # 字典转元组，只保留key
str(container) # 字典转字符串，保留key和value
set(container) # 字典转集合，只保留key文件
打开
python
open(name, mode, encoding)
# f = open('python.txt', 'r', encoding = 'utf-8')
name is 将要打开文件名的字符串 (r -> 只读，w -> 写入， a -> 追加内容)
f is open函数的文件对象读写
python
# 读取
f.read(num) # num is 从文件中读取的数据的长度(B)，若无num，则读全部
f.readlines() # 可以按照行的方式吧整个文件中的内容进行一次性读取，返回列表，其中每一行的数据为一个元素
文件指针的位置问题：
f = open("C:/Users/27788/Desktop/征文.txt", "r", encoding = 'utf-8')
print(f.read())
my_list = f.readlines() # 读一行用readline
print(f"文件的内容列表为：{my_list}")# 列表为空
当您调用 f.read() 时，文件指针会移动到文件末尾
后续调用 f.readlines() 时，文件指针已经在末尾，因此无法读取到任何内容
# for循环读取文件行
for line in f:
print(line)
python
# 写入
f.write("hello world")
f.flush() # 在Windows系统中，文件写入锁通常在数据刷新到磁盘后部分释放。其他进程可能可以读取文件（但写入仍可能被限制，取决于具体系统实现）。
# close方法内置了flush的功能
# 注意，使用open时，文件权限使用的w，则会将原有内容删除
# 文件的追加操作使用a，a模式下，会追加写入文件关闭
python
f.close()
with open语句 在内容块里操作，结束自动关闭文件
with open("xxx.txt", "r") as f:
print(f.read())异常
python
try:
可能发生错误的代码块
except:
处理异常代码
try:#捕获指定异常，以NameError为例
print(name)
except NameError as e:
print(e)
try:#捕获多个异常
print(1/0)
except:(NameError, ZeroDivisionError):
print("ZeroDivision错误")
Exception:捕获全部异常
try:
f = open("text.txt", "r", encoding = 'utf-8')
print(f.read())")
except Exception as e:
print(e)
else:#没有异常的话执行
print("恭喜你成功输出了全部内容")
finally:
f.close()
python的异常是具有传递性的，会自动向上抛,不需要和java一样throw模块
[from 模块名] import [模块| 类| 变脸| 函数| *] [as 别名] # * 代表导入模块全部功能
from 模块 improt xx时，会将该模块的内容执行一遍
若不想执行，可以将其写入如下句式：
python
if __name__ == '__main__'
测试代码其中__name__为py文件内置的变量，当主动执行该模块时，值为main
不同模块同名功能，都被导入，后覆盖前
如果模块文件中有'__all__'变量，则当使用from xxx import *导入时，只能导入这个列表中的元素
#eg:__all__=['test_A'] 只能使用括号内的
Python包：
python包为文件夹，包含模块和__init__.py文件
使用：
- import 包名.模块名
包名.模块名.xx - from 包名 import *
模块名.目标
注意：必须在__init__.py文件中添加__all__=[]'，控制允许导入的模块列表
python
import json
data = [{"name": "彦祖", "age": 22},{"name": "周杰伦", "age": 25}]
data = json.dumps(data) # python数据 -> json
# data = json.dumps(data, ensure_ascii = False) # 有中文的话得加上
data = json.loads(data) # json -> python数据 list or dict类
定义
python
类中定义方法：
def methodName(self, xx, xxx):
#self必须填写，表示类对象自身,成员方法内想访问成员变量，必须用self.变量；self在传参时不用理会
方法体
python
# 示例：
class Student:
name = None
age = None # 在构造函数中进行声明和赋值，可以省略
def __init__(self, name, age, address):
self.name = name
self.age = age
self.address = address
print("成功调用构造方法")
def __str__(self):# toString()
return f"Student name: {self.name} age: {self.age} address:{self.address}"
def __lt__(self, other):
return self.age < other.age内置方法
python
__init__#构造函数
__str__#toString
__lt__#less than
__le__#less and equal
__eq__#equal封装
私有成员变量：变量名以__开头
私有成员方法：方法名以__开头
继承(有单继承和多继承两类)
python
class Phone:
IMEI = None
producer = None
def call_by_4g(self):
print("4g通话")
class Phone2025(Phone):
face_id = True
def call_by_5g(self):
print("2025最新5g通话")
#===========================================================
class ClassName(dad1, dad2...)# 多继承下，在形参列表，谁先来，谁优先级高--同名的方法或属性
# 类内容体
pass#若无其他内容题，则使用pass补全语法，代表空
# 关于复写父类的方法和属性，在子类重新定义同名的即可
# 调用父类同名成员
1.父类名.成员变量 父类名.成员方法(self)
2.super().成员方法/变量多态
同样方法，不同对象不同行为====方法要父类传子类
用父类做定义声明
用子类具体行动
python
class Animal:
def speak(self):
pass
# Animal为抽象类（接口），含有抽象方法的类是抽象类，方法体是空实现的称之为抽象方法
class Dog(Animal):
def speak(self):
print("汪汪汪")
class Cat(Animal):
def speak(self):
print("喵喵喵")类型注解
对变量
变量：类型
python
name:str
my_list:list
my_list:list[int]
my_dict:dict[str, int]
my_set: set[int]
my_tuple: tuple[str, int ,bool] = ("jhf", 22, True)
# 元组设置时，需要将每一个元素都标记出来
# 字典设置时，需要两个类型，第一个是key，第二个是value
# 通过注释来注解
var1 = 1 # type: int
var2 = 2 # type: int
var3 = "d" # type: str
一般，无法直接看出变量类型时才加类型注解
var4 : int = random.randint(1, 10)
var5 : dict = json.loads({"jhf": 22, "zxy" : 23})
var6 : Student = func()
# 类型注解是提示的，并非强制的，只是帮助ide和开发者判断
var7 : int = "我是吴彦祖"
print(var7)#不会报错对方法
python
方法的形参和返回值的类型注解
def add(x: int, y: int) -> int:
return x + yUnion联合注解
python
Union # 定义联合注解
from typing import Union
my_list : list[Union[str, int]]
my_dict : dict[str, Union[str, int]]