python基础语法

在线编辑器

入门语法

print() 函数

def print(self, *args, sep=' ', end='\n', file=None)

格式化输出

格式化字符	含义
%s	字符串
%d	有符号十进制整数，%06d 表示输出的整数显示位数，不足的地方使用 0 补全
%f	浮点数，%.2f 表示小数点后只显示两位
%%	输出 %

示例

name = 'Ben'
age = 30

print("Name: %s, Age: %d" % (name, age))

f-string (Formatted string literals) 👍

name = 'Alice'
age = 30
print(f'Name: {name}, Age: {age}')

input()

username = input('请输入账号...')

数据类型

简单数据类型

• 整型（Integers）
  • 表示整数，不带小数点
  • 例如：100
• 浮点型（Floating point numbers）
  • 表示带有小数点的数字
  • 例如：15.20
• 复数（Complex Numbers）
  • 表示带有实部和虚部的数字
  • 例如：3.14j
• 布尔型（Boolean）
  • 表示真假
  • 有两个值，True 或 False
• 字符串（String）
  • 一串字符
  • 例如：“Hello World”
• 列表（List）
  • 有序的集合，可以包含任何数据
  • 例如：[1, ‘a’, 3]
• 元组（Tuple）
  • 类似于列表，但不可变
  • 例如：(1, ‘a’, 3)
• 集合（Set）
  • 无序且不重复的元素集合
  • 例如：{1, 2, 3}
• 字典（Dictionary）
  • 键值对的集合
  • 例如：{‘name’: ‘John’, ‘age’: 30}

查看数据类型

print(type('a')) # <class 'str'>
print(isinstance('a', str)) # True

字符串（String）

• 索引

a = 'hello,world'
print(a[0], a[-1]) # h d

数据类型转换

函数名	函数值
int(x, [基数] )	将数字或字符串转换为整数，如果x为浮点数，则自动截断小数部分
float(x)	将x转换成浮点型
bool(x)	转换成bool类型 的True或 False
str(x)	将x转换成字符串，适合人阅读

组合数据类型

概述

• 列表

• range

• 元组

• 字符串

序列的通用操作

函数	描述	备注
len(item)	计算容器中元素个数
del(item)	删除变量	del 有两种方式
max(item)	返回容器中元素最大值	如果是字典，只针对 key 比较
min(item)	返回容器中元素最小值	如果是字典，只针对 key 比较

	描述	表达式	结果	支持的数据类型
[::]	切片	‘0123456789’[::-2]	‘97531’	字符串、列表、元组
+	合并	[1, 2] + [3, 4]	[1, 2, 3, 4]	字符串、列表、元组
*	重复	[“Hi!”] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	字符串、列表、元组
in	3 in(1, 2, 3)	True	元素是否存在	字符串、列表、元组、字典
not in	4 not in (1, 2, 3)	True	元素是否不存在	字符串、列表、元组、字典
> >= == < <=	(1, 2, 3) < (2, 2, 3)	True	元素比较	字符串、列表、元组

列表👍

• List（列表） 是 Python 中使用最频繁的数据类型，在其他语言中通常叫做数组

li1 = list()
li2 = []
li3 = [1,2,3]
li4 = [4,5,6]
li6 = li3 + li4 # [1, 2, 3, 4, 5, 6]
print(4 in li6) # True

• 遍历

name_list = ['张三', '李四', '王五']
for item in name_list:
    print(item)
    
######
张三
李四
王五

• 带索引的遍历

name_list = ['张三', '李四', '王五']
for index, item in enumerate(name_list):
    print(index, item)
    
######
0 张三
1 李四
2 王五

• 其它操作

分类	关键字/函数/方法	说明
增加	列表.insert(索引, 数据)	在指定位置插入数据
	列表.append(数据)	在末尾追加数据
	列表.extend(列表2)	将列表2的数据追加到列表
修改	列表[索引] = 数据	修改指定索引的数据
删除	del 列表[索引]	删除指定索引的数据
	列表.remove[数据]	删除第一个出现的指定数据
	列表.pop	删除末尾数据
	列表.pop(索引)	删除指定索引数据
	列表.clear	清空列表
统计	len(列表)	列表长度
	列表.count(数据)	数据在列表中出现的次数
排序	列表.sort()	升序排序
	列表.sort(reverse=True)	降序排序
	列表.reverse()	逆序、反转

元组（不可变）

• 与列表类似，不同之处在于元组的元素不能修改

info_tuple = ("zhangsan", 18, 1.75)

range 函数

• 内建函数, 生成等差序列（不可变序列；不支持元素修改，不支持 + 和 * 操作）

## range(start,end,[step=1])
print(list(range(10))) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(range(1, 10))) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(range(1, 10, 2))) # [1, 3, 5, 7, 9]

字符串

• 加法和乘法

str1 = 'hello'
str2 = 'world'
str3 = str1 + str2

str3 = str2 * 3

• 索引

str1 = 'hello,world'
        0123     -2-1

• 字符串遍历

s = 'hello world'
for i in s:
    print(i)

字典👍

• dictionary（字典） 是 除列表以外最灵活的数据类型，类似于 Map

p1 = {
    'name': '张三',
    'age': 18,
    'gender': True,
    'height': 1.75
}

集合

• 无序且无重复元素的数据结构
• 与 dict 类似，是一组 key 的结合（不存储value）

s1 = set() # 空集合
s2 = {1, 2, 3, 4}

print(set([30, 40, 50])) # {40, 50, 30}
print(set((11, 22, 33))) # {33, 11, 22}
print(set('hello')) # {'e', 'h', 'o', 'l'}
print(set({'name': '张三', 'age': 20})) # {'age', 'name'}

可变类型 & 不可变类型

不可变数据类型在创建后，其值就不能被改变。Python中的以下数据类型是不可变的

• 数字（例如：int, float, complex）
• 字符串（例如：str）
• 元组（例如：tuple）
• 布尔类型（例如：bool）

可变类型

• 列表（例如：list）
• 字典（例如：dict）
• 集合（例如：set）

条件判断及循环

多分支结构

if-elif-else

day = int(input('请输入今天是星期几？'))
if day >= 1 and day <=5:
    print('工作日')
elif day >5 and day <=7:
    print('周末')
else:
    print('非法参数')

match

x = 10

match x:
    case 1:
        print('x is 1')
    case 2:
        print('x is 2')
    case _: # 匹配其他所有值
        print('x is other %s' % x)

循环

While

# 计算 1+2+...+100 的和
num = 1
sum = 0

while num <= 100:
    sum = sum + num
    num += 1
print(sum)

while 1:
    if num > 100:
        break
    sum = sum + num
    num += 1
print(sum)

for

for x in range(10):
    if x%5 != 0:
        continue
    print('这是5的倍数 %d' % x)

#####
这是5的倍数 0
这是5的倍数 5

异常处理

抓异常

try:
    print(1/0)
except Exception as e:
    print('有异常')
else:
    print('没有异常将会执行')
finally:
    print('无论如何都会执行')

抛异常

try:
    raise ZeroDivisionError('除0错误')
except ZeroDivisionError as e:
    print(e)

函数

格式

def sum_1(a, b):
    return a + b

# 缺省参数
def power(x, n = 2):
    return x*n

# 可变参数
def total(*args):
    print(args)

# 可变参数，接收字典
def f(**kwargs):
    for k, v in kwargs.items():
        print(k, v)
d = {'name': 'zhangsan', 'age': 20}
f(**d)

name zhangsan
age 20

作用域

# 全局变量
num1 = 10  # 不可变数据类型
num2 = 10
list1 = [1,2,3,4,5]   # 可变数据类型

def f():
    global num1  # 声明在f中使用的num1是全局变量num1
    num2 = 20  # 局部变量
    num1 = 20
    list1[2] = 8
    print('n1 >>>', num1) # n1 >>> 20
    print('n2 >>>',num2) # n2 >>>  20
    print('list1 >>>', list1) # list1 >>> [1, 2, 8, 4, 5]

f()
print('n1 >>>',num1) # n1 >>>  20
print('n2 >>>', num2) # n2 >>> 10
print('list1 >>>',list1) # list1 >>> [1, 2, 8, 4, 5]

匿名函数

• 映射

a = [1, 2, 3, 4, 5]
result = map(lambda x: x*3, a)
print(list(result)) # [3, 6, 9, 12, 15]

• 累积

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

from functools import reduce
result = reduce(lambda x, y: x*y, a)
print(result) # 120

• filter 过滤

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

result = filter(lambda x: x%2, a)
print(list(result)) # [1, 3, 5]

模块

常见标准库

模块	用途
os	os 模块提供了许多与操作系统交互的函数，例如创建、移动和删除文件和目录，以及访问环境变量等。
sys	sys 模块提供了与 Python 解释器和系统相关的功能，例如解释器的版本和路径，以及与 stdin、stdout 和 stderr 相关的信息
time	time 模块提供了处理时间的函数，例如获取当前时间、格式化日期和时间、计时等
datetime	datetime 模块提供了更高级的日期和时间处理函数，例如处理时区、计算时间差、计算日期差等
random	random 模块提供了生成随机数的函数，例如生成随机整数、浮点数、序列等
math	math 模块提供了数学函数，例如三角函数、对数函数、指数函数、常数等
re	re 模块提供了正则表达式处理函数，可以用于文本搜索、替换、分割等
json	json 模块提供了 JSON 编码和解码函数，可以将 Python 对象转换为 JSON 格式，并从 JSON 格式中解析出 Python 对象
urllib	urllib 模块提供了访问网页和处理 URL 的功能，包括下载文件、发送 POST 请求、处理 cookies 等

random

import random

print(random.randrange(1, 5, 1)) # random.randrange(start, stop, step) 含左不含右
print(random.randint(1, 5)) # 左右均包含，返回随机整数
print(random.random()) # [0.0, 1.0] 之间的随机整数

list = [1, 2, 3]

print(random.choice(list)) # 返回序列（列表 元组 字符串) 中的一个随机元素

random.shuffle(list)  # 将序列元素随机排列（打乱顺序）
print(list)

math

import math
print(math.cell(5.5)) # 向上
print(math.floor(5.5)) # 向下
print(math.sqrt(100)) # 求平方根

re 库

模式	描述	举例
\w	匹配字母数字及下划线	re.match(r’\w+', ‘A8’)
\W	匹配非字母数字下划线
\s	匹配任意空白字符，等价于[\t\n\r\f]
\S	匹配任意非空字符
\d	匹配任意数字，等价于[0-9]
\D	匹配任意非数字
\A	匹配字符串开始
\Z	匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串
\z	匹配字符串结束
\G	匹配最后匹配完成的位置
\n	匹配一个换行符
\t	匹配一个制表符
^	匹配字符串的开头
$	匹配字符串的末尾
.	匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符
[…]	用来表示一组字符，单独列出：[amk] 匹配 ‘a’, ‘m’ 或 ‘k’
[^…]	不在[]中的字符：[^abc] 匹配除了 a，b，c 之外的字符
*	匹配 0 个或多个的表达式
+	匹配 1 个或多个的表达式
?	匹配 0 个或 1 个由前面的正则表达式定义的片段，非贪婪方式
{n}	精确匹配 n 个前面表达式
{n,m}	匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
a|b	匹配 a 或 b
()	匹配括号内的表达式，也表示一个组

pip

# 更换镜像源
pip config set global.index-url https://mirrors.aliyun.com/pypi/simple
pip config get global.index-url
# 更新
pip install --upgrade pip
# 卸载
pip uninstall xxx
# 查看已安装
pip list

文件及io操作

文件写入

import os

path = os.getcwd() # 当前文件夹
filename = path + os.sep + '1.txt'
print(filename)
f = open(filename, mode='w', encoding='utf-8') # 打开文件
f.write('你好\n') # 写入
f.write('我不好')
f.close() # 关闭文件

文件读取

import os

path = os.getcwd() # 当前文件夹
filename = path + os.sep + '1.txt'
f = open(filename, 'r', encoding='utf-8') # 打开文件
context = f.readlines() # 读取
print(context)
f.close() # 关闭文件

文件追加

import os

path = os.getcwd() # 当前文件夹
filename = path + os.sep + '1.txt'
f = open(filename, 'a', encoding='utf-8') # 打开文件
f.write('hello\n') # 写入文件
a=['a','vb\n','c\n']
f.writelines(a) # 会将列表拼接起来输出 avb \n c \n 
# 关闭文件
f.close()

with

import os

path = os.getcwd() # 当前文件夹
filename = path + os.sep + '1.txt'
with open(filename, 'r', encoding='utf-8') as f:
    context = f.read()
    print(context)

面向对象

类及实例属性

# 定义一个类
class Player(object): # object 基类
    def __init__(self, name, age):  # 初始化函数（构造函数）
        self.name = name
        self.age = age

# 查看类型
print(type(tom)) # <class '__main__.Player'>
print(isinstance(tom, object)) # True
print(isinstance(tom, Player)) # True

zhangsan = Person('张三', 18)
zhangsan.height = 170 # 追加一些属性
print(zhangsan.__dict__, type(zhangsan.__dict__))

print(tom.__dict__, type(tom.__dict__)) # 获取实例（对象）的所有属性 {'name': '张三', 'age': 18, 'height': 170} <class 'dict'>

类属性(静态属性)

class Player(object):
    numbers = 0 # 类属性
    def __init__(self, name, age): # 初始化函数
        self.name = name
        self.age = age
        Player.numbers += 1 # 有点类似静态变量

zhangsan = Player('zhangsan', 20)
print('Player.numbers >>> ', Player.numbers) # 1
lisi = Player('lisi', 21)
print('Player.numbers >>> ', Player.numbers) # 2

实例方法

class Person(object): # 实例方法
    def __init__(self, name):
        self.name = name
    def show(self): # 这就是实例方法
        print('我的名字是%s' % self.name)

zhangsan = Person('张三')
zhangsan.show()

类方法

class Person(object):
    def __init__(self, name):
        self.name = name

class Chinese(Person):
    def __init__(self, name):
        super().__init__(name) # 调用父类构造器

zhangsan = Chinese('张三')
print(type(zhangsan)) # <class '__main__.Chinese'>
print(isinstance(zhangsan, Person)) # True

print(zhangsan.name) # 张三

静态方法

可以做一些校验

# 静态方法
class Person(object):
    @staticmethod
    def isvalid(**kwargs):
        if kwargs['age'] > 18:
            return True
        else:
            return False

infos = { 'name': 'zhangsan', 'age': 18}
if Person.isvalid(**infos):
    zhangsan = Person()
else:
    raise SyntaxError('不合法')

类的继承

class Person(object):
    def __init__(self, name):
        self.name = name

class Chinese(Person):
    def __init__(self, name, city):
        super().__init__(name) # 调用父类构造器
        self.city = city

zhangsan = Chinese('张三', '杭州')
print(type(zhangsan)) # <class '__main__.Chinese'>
print(isinstance(zhangsan, Person)) # True

print(zhangsan.name, zhangsan.city) # 张三 杭州

## 方法的重写略

多态

# 多态
class Animal(object):
    def speak(self):
        print('动物叫')

class Cat(Animal):
    def speak(self):
        print('喵喵')

class Dog(Animal):
    def speak(self):
        print('汪汪')

def speak(object):
    object.speak()

speak(Cat())
speak(Animal())

封装

class User(object):
    def __init__(self, name, age):
        self._name = name # 受保护的变量
        self.__age = age # 私有变量

    def get_age(self):
        return self.__age
    def set_age(self, age):
        if isinstance(age, int):
            self.__age = age
        else:
            raise Exception('格式错误')

zhangsan = User('张三', 18)
zhangsan.set_age(25)
print(zhangsan.get_age()) # 25

添加装饰器

class User(object):
    def __init__(self, name, age):
        self._name = name # 受保护的变量
        self.__age = age # 私有变量

    @property # 获取变量
    def name(self):
        return self._name
    @name.setter
    def name(self, name):
        self._name = name
        

zhangsan = User('张三', 18)
print(zhangsan.name) # 张三 # 不需要再加()
zhangsan.name = '李四'
print(zhangsan.name)

魔法方法

# 魔法方法
class User(object):
    def __init__(self, number):
        self.number = number

    def __str__(self): # 类似 java 的toString()
        return '重写str方法'

    def __add__(self, other): # 相加方法
        return self.number + other.number

    def __eq__(self, other): # equal方法
        return self.number == other.number

print(str(User(3))) # 重写str方法
print(User(4)) # 重写str方法
print(User(2) + User(5)) # 7
print(User(3) == User(3)) # False

汇总

	功能
__dict__	查看实例的所有属性
dir()	查看实例的所有属性和方法
__init__()	类的初始化函数
@classmethod	装饰器，表示类方法
@staticmethod	装饰器，表示静态方法
@property	装饰器，把方法变成属性访问
@属性.setter	装饰器，设置私有属性的值

界面开发

基于 wx 的 demo

# an
pip install wxpython

初始demo

import wx

app = wx.App() # 创建应用程序

frame = wx.Frame(None, size = (700, 500), pos = (500, 200), title = "Hello World") # 窗口

pl = wx.Panel(frame, -1) # 面板

frame.Show(True) # 显示窗口

static_text = wx.StaticText(pl, label = "Hello Dee", pos = (100, 100)) # 静态文本

btn = wx.Button(pl, label = "Click Me", pos = (100, 200)) # 按钮

btn.Bind(wx.EVT_BUTTON, lambda event: wx.MessageBox("触发点击事件")) # 绑定事件

app.MainLoop() # 运行主事件循环