快速学习Python（有其他语言基础）

快速入门Python（有其他语言基础）

通过本文章的学习，有其他语言基础的可以快速入门掌握Python

学习建议：内容已经极度精简，代码块里的内容要掌握好，在学习期间，要注意与其他语言的区别，例如在python中，区分是否为同一个代码块是通过空格来实现。
每一种python语法，通过所举例子的学习，基本能够掌握，重视对例子的理解！

祝各位彦祖学习愉快！

入门

print("hello world")
# print("hello world" + 666)这是错误的，python不允许将整数和字符串进行拼接
# 这是一个单行注释
""" 
这是多行注释
重新学习python
"""

变量 (变量无类型)

money = 100
print("钱包还有:", money)
#这里和java就有不同的了,print(内容1, 内容2, 内容3....)
#ctrl + d 是复制当前行到下一行
money -= 10
print(money)

数据类型与数据类型转换

# 用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)

标识符

# 标识符 字母数字下划线 中文-不推荐
名字 = "吴彦祖"
#多个单词组合变量名，用下划线进行分隔|||java一般驼峰命名
first_name = 名字

运算符

"""
+ - * /
// 取整除：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)

字符串扩展

# 字符串扩展
"""
三种定义方式 单引号，双引号，三引号
其中三引号定义法 使用变量接收-则为字符串，不使用则作为多行注释使用
引号可以嵌套，使用转义符\\ 或者 多引号中嵌套少一个引号的对应引号
"""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)}")

判断语句

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

#while 循环条件自定义，自行控制循环条件
#猜数字
import random
i = random.randint(1, 100)
flag = True
while flag:yourCount = int(input("请输入你猜的数字") )if yourCount == i:flag = Falseelif yourCount > i:print("你猜的数字大了")else:print("你猜的数字小了")
print("恭喜你猜对了,", end="")
print("你真是一个聪明鬼！")
# =========================================================
#打印九九乘法表
i = 1
while i <= 9:j = 1while j <= i:print(f"{j} * {i} = {j*i}\t", end="")j = j + 1i = i + 1print()

for

"""
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返回值类型为range2.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}朵")

函数

函数基础

#函数定义 先定义，后调用
def 函数名(传入参数):函数提交return 返回值

在python中，如果函数没有使用return语句返回数据，那么函数的返回值为None(特殊的字面量) 其类型为：<class ‘NoneType’>
None => False
None还可用于声明无初始内容的变量

global关键字在函数内使用，声明当前变量为全局变量

num1 = 100#全局变量
print(num1)
def say():"""用于试验python的函数功能:return: 返回一个返回值"""#num1 = 222#在函数内声明的为函数内的局部变量global num1#在函数内声明num1是全局变量num1 = num1 + 1print(num1)print("欢迎来到我的世界")return "这句话是返回值"print(say())

money = 5000000
name = None
def inquireMoney():global moneyprint("==========查询余额==========")print(f"{name}，您好，您的余额剩余：{money}元")def decreaseMoney(count):print("==========取款==========")global moneymoney -= countprint(f"{name}，您好，您取款{count}元成功")print(f"{name}，您好，您的账户剩余{money}元")def addMoney(count):print("==========存款==========")global moneymoney += countprint(f"{name}，您好，您存款{count}元成功")print(f"{name}，您好，您的账户剩余{money}元")def main():global namewhile 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:breakprint("感谢您的使用，祝您生活愉快")
name = input("请输入你的姓名")
main()

函数多返回值

def test_return():return 1, 2
x, y = test_return()
按照返回值顺序，对应接收

函数参数种类

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)

函数作为参数传递

def test_func(add):res = add(1, 2)print(res)
def my_add(a, b):return a + btest_func(my_add)

lambda匿名函数

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…

常用操作：

列表.index(元素) : 查询指定元素在列表的下标，找不到就报错ValueError
列表[下标] = 值 : 改值
列表.insert(下标, 元素):在指定下标插入元素列表.append(元素):追加元素
列表.extend(其他数据容器) : 将其他数据容器的内容去除，一次追加到列表尾部删除：
del 列表[下标]
列表.pop(下标) #下标为空时，pop列表末尾
列表.remove(元素) ：删除元素在列表中的第一个匹配项列表.clear()列表.count(元素) ： 元素在列表内的数量len()函数：计算容器中项目的个数

tuple(元组)

元组一旦定义完成，就不可修改(可以修改元组内list内容),数据可以是不同是数据类型
和list共同点：有序，较大元素数量，允许重复元素
定义：变量名称 = (e1, e2, e3)
注意，只有一个数据时，数据后要加逗号 my_tuple = (e1,) ,否则类型是str

index(元素)
count(元素)
len(元组)

str（字符串）

字符串支持下标索引 不可修改
my_str="wuyanzu"

字符串.index(元素)
字符串.replace(字符串1， 字符串2) ： 将字符串中的全部字符串1换为字符串2 （得到新字符串，原字符串不会改动）
字符串.split(分隔符字符串) ： 按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中 (字符串本身不变，而是得到了一个列表对象)
字符串.strip() : 字符串规整操作（去前后空格）
字符串.strip(字符串) ： 字符串规整操作（去前后指定字符串）
my_str = "12asdfgjkl21"
print(my_str.strip("12")) => "asdfgjkl" #按照的是单个字符进行规整 返回字符串
字符串.count(字符串)
len(字符串)

序列(一类数据容器) | 切片

内容连续，有序，可使用下表索引的一类数据容器：列表，元组，字符串等

切片：从一个序列中，取出一个子序列

语法：序列[起始下标:结束下标:步长] : 从序列中，起始下标开始，依次取出元素，到指定位置结束，得到一个新序列：
起始下标：可以留空，表示从头开始
结束下标：可以留空，表示到结尾
步长：1 表示一个个取元素，2 表示跳过1个元素取

对序列进行切片操作，不会影响序列本身，而是会得到一个新的序列

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()空集合

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等不可变的容器类型

空集合: {} 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的值

# 练习-理解如下代码
my_dict = {"王力宏":{"部门": "科技部","工资": 3000,"级别": 1},"周杰伦":{"部门": "市场部","工资": 5000,"级别": 2},"林俊杰":{"部门": "市场部","工资": 7000,"级别": 3},"张学友":{"部门": "科技部","工资": 4000,"级别": 1},"刘德华":{"部门": "市场部","工资": 6000,"级别": 2},}
print(my_dict)
flag = 0
for key in my_dict:flag += 1value = my_dict[key]if value["级别"] == 1:value["级别"] += 1value["工资"] += 1000if flag % 2 == 0:print(f"{key}: {value}")else:print(f"{key}: {value}",end="")

数据容器的通用方法

len(container)
max(container) # 字典使用时，只关心key
min(container)
sorted(container, [reverse = True])) # 返回值为listlist(container) # 字典转列表，只保留key
tuple(container) # 字典转元组，只保留key
str(container) # 字典转字符串，保留key和value
set(container) # 字典转集合，只保留key

文件

打开

open(name, mode, encoding)# f = open('python.txt', 'r', encoding = 'utf-8')
name is 将要打开文件名的字符串 (r -> 只读，w -> 写入， a -> 追加内容)
f is open函数的文件对象

读写

# 读取
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)

# 写入f.write("hello world") 
f.flush() # 在Windows系统中，文件写入锁通常在数据刷新到磁盘后部分释放。其他进程可能可以读取文件（但写入仍可能被限制，取决于具体系统实现）。
# close方法内置了flush的功能
# 注意，使用open时，文件权限使用的w，则会将原有内容删除
# 文件的追加操作使用a，a模式下，会追加写入文件

关闭

f.close()with open语句 在内容块里操作，结束自动关闭文件
with open("xxx.txt", "r") as f:print(f.read())

异常

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时，会将该模块的内容执行一遍
若不想执行，可以将其写入如下句式：

if __name__ == '__main__'测试代码

其中__name__为py文件内置的变量，当主动执行该模块时，值为main

不同模块同名功能，都被导入，后覆盖前

如果模块文件中有'__all__'变量，则当使用from xxx import *导入时，只能导入这个列表中的元素

#eg:__all__=['test_A'] 只能使用括号内的

Python包：

python包为文件夹，包含模块和__init__.py文件
使用：

1. import 包名.模块名
   包名.模块名.xx
2. from 包名 import *
   模块名.目标
   注意：必须在__init__.py文件中添加__all__=[]'，控制允许导入的模块列表

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

类

定义

类中定义方法： def methodName(self, xx, xxx):#self必须填写，表示类对象自身,成员方法内想访问成员变量，必须用self.变量；self在传参时不用理会方法体

# 示例：
class Student:name = Noneage = None # 在构造函数中进行声明和赋值，可以省略def __init__(self, name, age, address):self.name = nameself.age = ageself.address = addressprint("成功调用构造方法")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

内置方法

__init__#构造函数
__str__#toString
__lt__#less than
__le__#less and equal
__eq__#equal

封装

私有成员变量：变量名以__开头
私有成员方法：方法名以__开头

继承(有单继承和多继承两类)

class Phone:IMEI = Noneproducer = Nonedef call_by_4g(self):print("4g通话")
class Phone2025(Phone):face_id = Truedef call_by_5g(self):print("2025最新5g通话")
#===========================================================
class ClassName(dad1, dad2...)# 多继承下，在形参列表，谁先来，谁优先级高--同名的方法或属性# 类内容体pass#若无其他内容题，则使用pass补全语法，代表空
# 关于复写父类的方法和属性，在子类重新定义同名的即可# 调用父类同名成员
1.父类名.成员变量 父类名.成员方法(self)
2.super().成员方法/变量

多态

同样方法，不同对象不同行为====方法要父类传子类
用父类做定义声明
用子类具体行动

class Animal:def speak(self):pass
# Animal为抽象类（接口），含有抽象方法的类是抽象类，方法体是空实现的称之为抽象方法
class Dog(Animal):def speak(self):print("汪汪汪")
class Cat(Animal):def speak(self):print("喵喵喵")

类型注解

对变量

变量：类型

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)#不会报错

对方法

方法的形参和返回值的类型注解
def add(x: int, y: int) -> int:return x + y

Union联合注解

Union # 定义联合注解
from typing import Union
my_list : list[Union[str, int]]
my_dict : dict[str, Union[str, int]]