Python极简入门_适用于已有C语言基础快速扩展第二语言

数据类型

变量

  • 变量

    变量用于储存可变的数据

    • 可以使用等号给变量赋值

    • 变量名区分大小写，开头不能是数字

    • 在Python中，变量的类型不需要预先声明，可以直接给变量赋某个数据类型的值，这时的变量就会自动变成那个数据类型

  • 显示变量数据类型

    使用type函数可以将某个变量的数据类型写成字符串，配合print可以打印这个变量的数据类型

    #使用方法：
message = "这是字符串"
print(message)#这样会输出message里的内容
print(type(message))#这样会输出message的数据类型
#运行结果将是<class 'str'>

    使用isinstance函数可以检测某个变量是否属于某种类型

    print(isinstance(message, str))  #输出True

运算符

  • 算术运算符

    • 幂：**，前为进行幂次运算的数，后为幂次

    • 整除：//，取整数的商；取余：%

    • 自加：a += i，将a与i相加后的值保存到a

  • 比较运算符
    • 相等==，不等!=
    • >，<，>=，<=
  • 逻辑运算符

    and，or，not

基本数据类型

  • 字符串str

    字符串用引号（单引号和双引号作用一样）括起来，可以赋值给变量

    message = "Hello"

print(message)#输出结果是Hello

    字符串有一个重要的操作就是追加：在Python里可以方便的追加字符，而不必亲自找到末尾内存地址并分配内存

    'Hello,' + name#name是字符串变量，将被追加到Hello,后
#或者可以格式化字符串，将变量输出到字符串中，如下
f'Hello,{name}'#这样的效果同上，但是更安全，避免了变量不是字符串类型

    其他字符串操作

    s = " Hello World "
s.strip()        #去掉首尾空格
s.lower()        #全小写
s.upper()        #全大写
s.replace("World", "Python")#将前面匹配的字符串替换为后面的字符串
s.split(" ")     #按空格分割，得到列表
  • 整型int

    表示整数

  • 浮点数float

    表示小数

  • 布尔型bool

    用于判断真假是否，有True和False两个取值（也要区分大小写）

    is_running = True

print(is_running)#输出结果是True

列表list

  • 列表与数组

    将基本的数据类型组合排列起来，就得到一个列表

    类似于C语言的数组，在内存中都是连续有序存储的，同样可以通过下标访问某个位置：a[0]，a[1]

    但是其更简单强大：可以像结构体一样混用不同数据类型，可以像链表一样增加新的元素，而且Python会自动回收内存，不像C要自己malloc和free

  • 列表的操作

    使用中括号表示一个列表，用逗号分割列表中的元素

    #列表使用方法
fruits = ['苹果','香蕉','西瓜']#一个名叫fruits的列表里有三个字符串元素
print(fruits[2])#这样输出的就是西瓜

fruits[0] = '桃子'#这样就将原来列表中的苹果改成了桃子
print(fruits)#这样输出的就是['桃子','香蕉','西瓜']

    列表有一个重要的操作就是切片：在Python中，可以直接对列表切片以取出某部分，不必单独写一个循环遍历每一个元素

    nums = [0, 1, 2, 3, 4, 5]
nums[1:4]    #得到[1, 2, 3]（从索引1到3，不含4）
nums[:3]     #得到[0, 1, 2]（开头到索引2）
nums[2:]     #得到[2, 3, 4, 5]（索引2到末尾）
nums[-1]     #得到5（最后一个元素）

    其他列表操作

    len(fruits)#计算列表长度，也就是列表包含元素数量
fruits.append('橘子')#增加元素，现在fruits有四个元素，第四个是橘子
fruits.pop()	#删除最后一个元素，返回值是这个被删的元素
fruits.pop(0)	#删除指定位置元素
fruits.remove('香蕉')	#删除指定的元素（只删第一个）
fruits.insert(1, '葡萄')	#在位置1插入元素
  • 元组tuple

    类似列表，但是不能被修改，不能修改或者增加元素

    使用小括号表示一个元组

    fruits = ('苹果','香蕉','西瓜')
#单元素元组写法要在后面加逗号，否则只会识别为一个带括号的元素
t = (1,)   # 这才是元组

字典

  • 字典的创建

    一种键值对的结构，写法如下：

    person = {
	'name':'小明',#一个关键词以及其所对应的值
	'age':18，
	'city':'广州'
}
  • 字典的引用
    person['name']#索引字典person中关键词为'name'所对应的值
print(person['name'])#这样输出的就是小明
  • 字典的操作
    person.keys()#得到字典中所有的键
#返回的是：dict_keys(['name','age','city'])
person.values()#得到字典中的所有值
#返回的是：dict_values(['小明','18','广州'])
person.items()#得到所有键和值
#返回的是包含元组的列表：dict_items：（[（'name'，'小明'），（'age'，'18'），（'city'，'广州'）]）

    其他字典操作

    person['height'] = 175        #增加新键值对
del person['age']             #删除键值对
person.get('age', '未知')      #安全获取，键不存在时返回默认值

语句

循环

  • while循环

    一个while循环在Python中是这么写的

    count = 0#循环计数的变量
while count < 5:#进入循环的条件
    print(count)
    count += 1#循环需要能够退出
  • 循环控制
    break     #直接跳出整个循环
continue  #跳过本次循环剩余代码，进入下一次循环
  • for循环

    一个for循环在Python中是这么写的

    fruits = ['苹果','香蕉','西瓜']#列表/元组适用于循环
for f in fruits：#for表示循环，f是循环所用变量，in表示来自哪个列表/元组
	print(f) #循环变量f是当前循环所用列表中元素的代称
#运行这一代码，将会输出：苹果，香蕉,西瓜（列表遍历完成后退出）

    列表用于循环，反之循环也可以用于构建列表：

    squares = [x**2 for x in range(5)]  #得到[0, 1, 4, 9, 16]
  • range遍历数字

    for常和range搭配，用于控制遍历次数

    for i in range(10)#现在有10个数，将会执行十遍
	print(i)
#运行这一代码，将会输出：0，1，2……9（从0开始十个数）
  • 遍历字典

    字典可用于循环，例如遍历一个字典中的所有items

    #仍以前文的person字典为例
for k,v in person.items():
	print(k,":",v)
#这样就能打印出：
#name：小明
#age：18
#city：广州

判断

  • if判断
    if age < 18:
	print('未成年')
elif age < 65:
	print('成年人')#else if 缩写，在只有两个判断选项时可以不写
else:
	print('老年人')#不符合上述条件则选此项
  • 逻辑判断条件

    利用逻辑运算符与布尔量，可以构建复杂的判断条件

    if age >= 18 and age < 65:   # 与
if score > 90 or cheat:      # 或
if not is_weekend:           # 非

函数

定义函数

  • 函数的结构

    使用关键字def来定义一个函数

    def hello():
	return 'hello world!'

#使用这个函数：
print(hello())
  • 带参数的函数

    函数后的括号用于声明函数所用的参数

    def hello(name):
	return f'hello, {name}'

#使用这个函数：
print(hello('小明'))

    这种写法适用于各种计算

    num = [1,2,3,4,5]

def sum(num)
	total = 0#函数内定义的变量在函数外不起作用
	for i in num
		total += i
	return total

特殊的函数用法

  • 默认参数

    这种写法让需要参数的函数可以在没有给参数的情况下以默认参数工作

    def hello(name='游客'):
    return f'hello, {name}'

hello()        # 'hello, 游客'
hello('小明')   # 'hello, 小明'
  • 不定长参数

    不确定需要几个参数的情况下，可以使用这种写法，参数将会被打包为元组

    def sum_all(*nums):      #*表示接收任意数量的参数，打包成元组
    total = 0
    for n in nums:
        total += n
    return total

sum_all(1, 2, 3, 4)      #返回10
  • lambda匿名函数

    这是一种将简单函数简写的写法

    add = lambda x, y: x + y
add(3, 5)   #得到8

面向对象OOP

什么是面向对象

  • 面向过程编程

    也就是写C语言的思路，将整个程序的执行过程写出来，代码写的是过程中需要什么数据和需要对这些数据按什么逻辑什么顺序做什么操作

    #这是数据
scores = [85, 92, 78, 90, 88]

#步骤1：计算总分
total = 0
for s in scores:
    total += s

#步骤2：计算平均分
avg = total / len(scores)

#步骤3：打印结果
print(f"平均分：{avg}")
  • 面向对象编程

    面向对象编程（Object-Oriented Programming，OOP），区别在于数据和操作数据的方法不再是分离的，而是被打包在了一起，也就成为了“对象”，使用时直接让对象做自己的事

    class ClassScore:
    def __init__(self, scores):
        self.scores = scores   #数据打包在对象里
    
    def avg(self):             #操作方法也打包在对象里
        total = 0
        for s in self.scores:
            total += s
        return total / len(self.scores)

# 创建对象，直接调用它的方法
class1 = ClassScore([85, 92, 78, 90, 88])
print(f"平均分：{class1.avg()}")

OOP核心概念

  • 类class

    创建一个类的过程称为封装，封装将数据与操作打包在一起，定义了一个对象有什么数据，能做什么事情：对象中的数据称为属性，对象能做的事称为方法

    class Calculator:#这个类Calculator包含三个方法
	def __init__(self.num):#必需的部分，用于定义对象数据初始值
		self.num=num#属性

	def sum(self)： #求总值，是类的方法
		total = 0
		for i in self.num:
			total += i
		return total
	
	def avg(self):	#求平均值
		return self.sum() / len(self.num)

    创建之后就可以使用这个类，使用前需要先初始化，创建出对象/实例

    nums = [1,2,3,4,5]
calc = Calculator(nums)#向类传入一个参数，现在calc成为类的实例/对象

print(calc.sum())#初始化之后就能使用类的方法
  • 继承

    一个类可以"继承"另一个类的属性和方法，例如科学计算器继承普通计算器的加减乘除，在此之上增加一个平方功能

    class ScientificCalculator(Calculator):   #继承Calculator
    def power(self):
        return [x ** 2 for x in self.num]

calc = ScientificCalculator([1, 2, 3])
calc.sum()    #继承来的方法，仍可用
calc.power()  #新创建方法
  • 多态

    不同类的对象，可以用同样的方法名做不同的事。比如 Cat 和 Dog 都可以有 speak() 方法，一个喵一个汪

  • 特殊方法

    前文的__init__是一种特殊方法，用于给予初始值，关于类还有其他的特殊方法

    def __str__(self):           #被print()调用时的显示内容
    return f"Calculator with {len(self.num)} numbers"

def __len__(self):           #被len()调用时的显示内容
    return len(self.num)

Python拓展

模块与导入

  • import导入模块

    与C的#include一样，Python可以使用import导入模块以调用其中功能

    import math           #导入整个模块
math.sqrt(16)
  • from部分导入

    在只需要模块中的部分内容时，可以只导入其中指定的部分

    from math import pi   #只导入模块中的某个函数/变量
print(pi)             #3.14159...
  • as为导入的部分起别名

    类似typedef，为导入的模块起一个别名方便之后使用

    import datetime as dt #可以为导入的模块起别名
dt.datetime.now()     #当前时间

异常处理

  • try-except异常处理

    让程序尝试运行一段可能会出错的代码，为防出错时整个程序直接崩溃，就让程序去try一下，在真的出错时程序不会直接终止，而是会执行except块里的备用代码

    try:#以下是尝试执行可能出错的代码
    num = int(input("输入数字: "))
    print(10 / num)
except ValueError:
    print("输入的不是数字")
except ZeroDivisionError:
    print("不能除以0")
finally:
    print("无论是否出错，都会执行这里")

    这样的写法有如下优点：给用户友好的错误提示，提供备选方案，记录日志但不中断服务

  • 异常类型

    可以看到上述例程中的错误类型如ValueError等，这些是Python启动时就已经定义好的类，可以直接使用，常见的内置异常如下：

    ValueError      # 数值转换错误
TypeError       # 类型错误
KeyError        # 字典键不存在
FileNotFoundError  # 文件不存在
ZeroDivisionError  # 除以零

    异常的本质是特殊的类，使用类而非关键字是为了继承和实例化，便于扩展自定义属性、方法与第三方库，try-except的本质就是捕获类的实例，

    因此也可以创建自己的异常类型，继承自Exception

    class AgeTooYoungError(Exception):
    """自定义异常：年龄太小"""
    pass
#使用类而非关键字是为了类的扩展性：
class BalanceInsufficientError(Exception):
    def __init__(self, balance, required):
        self.balance = balance
        self.required = required
        super().__init__(f"余额不足: 有{balance}, 需要{required}")
  • raise主动触发异常

    try语句是在遇到异常时用except接住，而还有一种用法是raise语句主动去触发一个异常，让程序知道发生问题了，进入异常处理流程

    #继续上面的例程，使用自定义异常
def register_user(age):
    if age < 18:
        raise AgeTooYoungError(f"年龄{age}小于18岁")
		#在不满条件时触发异常，让程序知道这是有问题的
    print("注册成功")

try:
    register_user(15)#注册失败: 15小于18，会触发AgeTooYoungError
except AgeTooYoungError as e:#raise与try配合使用，处理异常
    print(f"注册失败: {e}")  #错误处理
  • 与if-else的区别

    可以发现使用try的做法很像看起来很像在C中用if写各种分支条件，如果不符所有的合法条件就用一个else来处理

    那么为什么还需要造一个try呢？

    • if-else：用于能够预判并且愿意主动检查的情况，是正常流程控制

      用于经常发生且检查的代价很小的情况

    • try-except：用于无法预判或不想预判的意外情况，是异常处理机制

      用于极少发生且检查很贵(需要调取数据库或者查API的情况)的情况

      此外适用于存在并发条件的情况(检查的那一刻到执行的那一刻之间，状态可能已经变了(多线程/分布式环境)，这时用try配合原子操作

    比如经典的程序员测试BUG笑话：去酒吧点了炒饭，结果酒吧炸了。

    • 如果常有顾客问菜单有没有某种酒，而这个检查只需要看一眼菜单(经常发生或检查很便宜的情况)，那就用if
    • 如果是问某种酒还有没有货(需要检查库存，代价比较大，而且是动态信息，需要处理竞态条件)，或者是进来点炒饭(虽然是静态信息，但这种情况很少发生)，那就优先用try，因为出错后再想办法弥补比一开始就设法避免一切错误更容易
posted @ 2026-04-28 14:47  无术师  阅读(12)  评论(0)    收藏  举报