【备战测开】—— 编程语言Python（一）

Big David

1019人浏览 · 2024-04-14 20:13:05

Big David · 2024-04-14 20:13:05 发布

按照下面的思维导图搭建知识体系：
在这里插入图片描述

1 变量

1.1 定义变量

标识符是编程时使用的名字，用于给变量、函数、语句块等命名，Python 中标识符由字母、数字、下划线组成，不能以数字开头，区分大小写。

以下划线开头的标识符有特殊含义：
（1）_xxx ，表示不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 导入
（2）__xx，表示私有成员
（3）__xx__，表示 Python 中内置标识，如：__init__()表示类的构造函数

Python定义变量的详细介绍参考：Python变量：变量的定义、赋值、修改、删除等操作

1.2 关键字

and	exec	not	assert	finally	or
break	for	pass	class	from	print
continue	global	raise	def	if	return
del	import	try	elif	in	while
else	is	with	except	lambda	yield

表中是 Python 中的关键字（保留字），在自定义标识符时不能使用关键字

1.3 命名规则

Python的命名规则参考该博客：python变量、函数、类的命名规则

1.4 基本数据类型

主要学习了博客：Python六大数据类型
python3数据类型主要分为以下六大类：

Numbers（数字）
String（字符串）
List（列表）
Tuple（元组）
Dictionary（字典）
Set（集合）

可变：List、Dict、Set
不可变：Num、Str、Tuple

1.5 类型转换

# int(x) :将x转化为一个整数，向下取整
int(5.1) # 5
# float(x):将x转化为一个浮点数
float(2)
# complex(x [,imge])：将x转化为一个复数
complex(1,2)
# str(x)：将x转化为一个字符串
str(1123)
# repr(x)：将对象 x 转换为表达式字符串
repr(1+2j)
# eval(x)：用来计算在字符串中的有效Python表达式,并返回一个对象，其实就是能计算字符串表达式，并得到结果
eval('1*2+4//2')
# tuple(s)：将序列s转化为一个元组
tuple("qweqwe")
# list(s)：将序列s转化为一个列表
list({1,2,3})
# set(s)：将序列s转化为可变集合，可用于列表去重
set([1,2,3,'a','a',2,3])
# dict()：创建一个字典
dict()
# frozenset(s)：将s转换为不可变集合
frozenset([1,2,3])
# chr(x)：将一个整数转化为其ASCIIi码对应的字符
chr(100)
# ord(x)：将一个字符转化为一个整数，该整数为x对应的ASCII码
ord('a')
# hex(x)：将一个整数转换为一个十六进制字符串
hex(10)
# oct(x)：将一个整数转换为一个八进制字符串
oct(100)

1.6 Python一些基础知识

1 引号
Python 可以使用引号（‘）、双引号（"）、三引号（’‘’ 或 “”"）来表示字符串，引号的开始与结束须类型相同，三引号可以由多行组成。如下所示

id = '001'

name = "张三"

skill = '''
唱歌
跳舞'''

skill = """
唱歌
跳舞"""

2 编码
Python2 中默认编码为ASCII，假如内容为汉字，不指定编码便不能正确的输出及读取，比如我们想要指定编码为 UTF-8，Python 中通过在开头加入 # -*- coding: UTF-8 -*- 进行指定。

Python3 中默认编码为 UTF-8，因此在使用 Python3 时，我们通常不需指定编码。

3 输入输出

print()
name = input()
print('Hi',name)

4 缩进
Python 不使用 {} 来控制类、函数、逻辑判断等，而是使用缩进，缩进的空格可变
5 多行

a = 128
b = 1024
c = 512
d = a + \
    b - \
    c

如果包含在 []、{}、()括号中，则不需要使用\

arr = {
    a,
    b,
    c
}

6 注释

# 我是单行注释

'''
我是多行注释
我是多行注释
'''

"""
我是多行注释
我是多行注释
"""

2 运算符和表达式

详细介绍见：Python – 常见的运算符与表达式
在这里插入图片描述

3 流程控制

3.1 条件分支

进行逻辑判断，Python 提供了 if、elif、else 来进行逻辑判断，如下示例：

a = 1
if a == 1:
	print("asd")
elif a == 2:
	print('a')
else:
	print('q')

3.2 循环

for 循环可以遍历任何序列，比如：字符串

str = 'Python'
for s in str:
    print(s)

while循环满足条件时进行循环，不满足条件时退出循环

sum = 0
m = 10
while m > 0:
    sum = sum + m
    m = m - 1
print(sum)

break：用在 for 循环和 while 循环语句中，用来终止整个循环
continue：continue 用在 for 循环和 while 循环语句中，用来终止本次循环
pass：pass 是空语句，它不做任何事情，一般用做占位语句，作用是保持程序结构的完整性

if True:
	pass

4 基本数据结构

4.1 字符串

字符串是 Python 的一种数据类型，它可以通过单引号'、双引号 "、三引号 ''' 或 """ 来定义
（1）访问：
访问单个字符

s = 'Python'
# 访问第一个字符 P
print(s[0])

访问范围内字符

s = 'Python'
# 访问 yt
print(s[1:3])
# 访问 Pyt
print(s[:3])
# 访问 hon
print(s[3:])

（2）单个字符编码
Python 使用了 ord() 函数返回单个字符的编码，chr() 函数把编码转成相应字符

s = 'A'
print(ord(s))
print(chr(65))

（3）转义符
在这里插入图片描述
（4）运算符

s1 = 'Hello'
s2 = 'Python'
print('s1 + s2 -->', s1 + s2)
print('s1 * 2 -->', s1 * 2)
print('s1[0] -->', s1[0])
print('s1[0:2] -->',s1[0:2])
print('"H" in s1 -->','H' in s1)
print('"H" not in s1 -->','H' not in s1)
print('\\r -->', R'\r222222')

（5）格式化
Python 使用 % 格式化字符串，常用占位符：

占位符	描述
%s	格式化字符串
%d	格式化整数
%f	格式化浮点数

可以使用字符串的 format() 方法进行格式化

print('{0} {1}'.format('a','s'))

Python 中的序列是一块可存放多个值的连续内存空间，所有值按一定顺序排列，每个值所在位置都有一个编号，称其为索引，我们可以通过索引访问其对应值。字符串就是序列结构，除此之外常见的序列结构还包括列表、元组

序列的概念参考：Python 基础（五）：序列
这里对内置函数做一个记录：
在这里插入图片描述

4.2 列表

Python 中没有数组，而是加入了功能更强大的列表（list），列表可以存储任何类型的数据，同一个列表中的数据类型还可以不同；列表是序列结构，可以进行序列结构的基本操作：索引、切片、加、乘、检查成员。

创建

l = [1024, 0.5, 'Python']

访问：通过索引访问列表中的值，还可以使用 : 截取范围内的元素

l = [1024, 0.5, 'Python']
print('l[0] -->', l[0])
print('l[1:] -->', l[1:])

更新


l = [1024, 0.5, 'Python']
# 修改列表中第二个元素
l[1] = 5
# 向列表中添加新元素
l.append('Hello')
print('l[1] -->', l[1])
print('l -->', l)

删除：del

l = [1024, 0.5, 'Python']
# 删除列表中第二个元素
del l[1]
print('l -->', l)

常用方法

(1) count()：统计列表中某个元素出现的次数

l = ['a', 'a', 'b']
l.count('a')

(2) index()：查找某个元素在列表中首次出现的位置（即索引）

l = ['a', 'a', 'b']
l.index('a')

(3) remove()：移除列表中某个值的首次匹配项

l = ['d', 'b', 'a', 'f', 'd']
l.remove('d')
print("l -->", l)

(4) sort()：对列表中元素进行排序

l = ['b', 'a', 'c']
l.sort()

(5) copy()：复制列表

l = ['d', 'b', 'a', 'f', 'd']
a = l.copy()
a

4.3 元组

元组（tuple）与列表类似，但元组是不可变的，可简单将其看作是不可变的列表，元组常用于保存不可修改的内容

创建

t = (1024, 0.5, 'Python')

访问


t = (1024, 0.5, 'Python')
print('t[0] -->', t[0])
print('t[1:] -->', t[1:])

修改：元组中元素不能被修改，我们要用重新赋值的方式操作

t = (1024, 0.5, 'Python')
t = (1024, 0.5, 'Python', 'Hello')
print('t -->', t)

删除：元组中的元素不能被删除，我们只能删除整个元组


t = (1024, 0.5, 'Python')
del t
print('t -->', t)

常用方法
（1）len()


t = (1024, 0.5, 'Python')
print('len(t) -->', len(t))

（2）max() 和 min()


t = ('d', 'b', 'a', 'f', 'd')
print('max(t) -->', max(t))
print('min(t) -->', min(t))

（3）tuple()：将列表转换为元组


l = ['d', 'b', 'a', 'f', 'd']
t = tuple(l)
print('t -->', t)

4.4 集合

集合（set）与字典相同均存储 key，但也只存储 key，因 key 不可重复，所以 set 的中的值不可重复，也是无序的

创建：使用花括号 {} 或者 set() 函数创建，如果创建空集合只能使用 set() 函数

s = {'a', 'b', 'c'}

# 使用 set 函数
s = set(['a', 'b', 'c'])

# 空集合
s = set()

添加元素可以使用 add 或 update 方法，如果元素已经存在，则不进行操作

s = {'a', 'b', 'c'}
s.add('d')
s.update('e')
s.add('a')

删除元素使用 remove 方法

s = {'a', 'b', 'c'}
s.remove('c')

清空集合使用 clear 方法

s = {'a', 'b', 'c'}
s.clear()
s

获取集合的长度

s = {'a', 'b', 'c'}
len(s)

4.5 字典

以键-值（key-value）的方式存在

创建字典

d = {'name':'小明', 'age':'18'}
# 使用 dict 函数
l = [('name', '小明'), ('age', '18')]
d = dict(l)
d = dict(name='小明', age='18')
d = dict()
d = {}

字典中的值通过 key 进行访问

d = {'name':'小明', 'age':'18'}
d['age']
d.get('age')

修改

d = {'name':'小明', 'age':'18'}
d['age'] = '20'
d

清空

d = {'name':'小明', 'age':'18'}
d.clear()
d

获取字典的长度

d = {'name':'小明', 'age':'18'}
len(d)

5 函数

函数就是一段实现特定功能的代码，使用函数可以提高代码的重复利用率

5.1 定义

Python 使用 def 关键字来声明函数

def 函数名(参数):
	函数体
	return 返回值

如果要定义一个无任何功能的空函数，函数体只写 pass 即可

def 函数名():
	pass

当我们不确定参数的个数时，可以使用不定长参数，在参数名前加 * 进行声明

def 函数名(*参数名):
	函数体

使用 lambda 定义匿名函数

lambda 参数 : 表达式

举例


# 空函数
def my_empty():
    pass

# 无返回值
def my_print(name):
    print('Hello', name)

# 有返回值
def my_sum(x, y):
    s = x + y
    print('s-->', s)
    return s
    
# 不定长参数
def my_variable(*params):
    for p in params:
        print(p)

# 匿名函数
my_sub = lambda x, y: x - y

5.2 参数传递

参考博客：详解Python函数参数定义及传参（必备参数、关键字参数、默认可省略参数、可变不定长参数、*args、**kwargs）
Python函数参数传参的种类：必备参数、关键字参数、默认可省略参数、不定长元组参数、不定长关键字参数
1、必备参数：仅赋值传参，在调用函数的时候，定义的参数要全部都有赋值，否则执行的时候代码会报错

#!/usr/bin/env python
# -*- coding: utf-8 -*-


# 演示获得数据库配置参数，使用必备参数
def demo_get_conf1(user, pw, host, port, db, charset):
    "打印得到的数据库配置"
    print('host: ', host)
    print('port: ', port)
    print('user: ', user)
    print('pw: ', pw)
    print('db: ', db)
    print('charset: ', charset)


demo_get_conf1('root', '1234', '127.0.0.1', '3306', 'tests', 'utf8')

2、必备参数：键值对传参（关键字参数）

#!/usr/bin/env python
# -*- coding: utf-8 -*-


# 演示获得数据库配置参数，使用必备参数
def demo_get_conf1(user, pw, host, port, db, charset):
    "打印得到的数据库配置"
    print('host: ', host)
    print('port: ', port)
    print('user: ', user)
    print('pw: ', pw)
    print('db: ', db)
    print('charset: ', charset)


demo_get_conf1(
    charset='utf8',
    pw='1234',
    user='root',
    host='127.0.0.1',
    port='3306',
    db='tests')

3、默认可省略参数：这个参数必须在后面，否则调用的时候按照顺序赋值的时候，少传递一个就不是这个有默认值的

#!/usr/bin/env python
# -*- coding: utf-8 -*-


# 演示获得数据库配置参数，使用默认可省略参数
def demo_get_conf2(user, pw, host, port, db, charset='utf8'):
    "打印得到的数据库配置"
    print('host: ', host)
    print('port: ', port)
    print('user: ', user)
    print('pw: ', pw)
    print('db: ', db)
    print('charset: ', charset)

demo_get_conf2('root', '1234', '127.0.0.1', '3306', 'tests')

4、不定长元组参数（*args）：不确定数量的参数，定义一个参数把传入的参数组合成元组，来接收函数调用时传递过来的N个参数，在函数体内以元组形式按顺序读取。

#!/usr/bin/env python
# -*- coding: utf-8 -*-


# 演示获得数据库配置参数，使用可变长元组参数
def demo_get_conf3(host, port, *cnf):
    "打印得到的数据库配置"
    print('host: ', host)
    print('port: ', port)
    print('user: ', cnf[0])
    print('pw: ', cnf[1])
    print('db: ', cnf[2])
    print('charset: ', cnf[3])


demo_get_conf3('127.0.0.1', '3306', 'root', '1234', 'tests', 'utf8')

5、不定长字典参数（**kwargs）
不定长字典参数，就是不确定数量的参数，定义一个字典，按键值对形式来接收函数调用时传递过来的N个参数，在函数体内以字典形式按键值对读取。这样在传递的时候，就可以不用在意顺序问题了：

#!/usr/bin/env python
# -*- coding: utf-8 -*-


# 演示获得数据库配置参数，使用可变长字典参数
def demo_get_conf7(host, port, **cnf):
    "打印得到的数据库配置"
    print('host: ', host)
    print('port: ', port)
    print('user: ', cnf['user'])
    print('pw: ', cnf['pw'])
    print('db: ', cnf['db'])
    print('charset: ', cnf['charset'])


demo_get_conf7('127.0.0.1', '3306', user='new_user', pw='5678', db='tests', charset='utf8mb4')

5.3 作用域

参考博客：Python 函数作用域
Python中变量作用域分4种情况：

local，局部作用域，即函数中定义的变量
父级函数的局部作用域，即此函数的上级函数的局部作用域
global,全局变量
build-in,系统模块，如:int,max函数等

优先级顺序为：局部作用域(L)>父级函数作用域(E)>全局作用域(G)>系统模块(B)

x = max(1, 6)  # max为系统变量，它的作用域为python的所有模块
y = 1  # y为全局变量，它的作用域为当前模块

def outer():
    i = 3    # i的作用域为当前函数，包括嵌套函数   
    def inner():
        count = 2   # count为局部变量，作用域只在当前函数有效

函数中修改不了全局作用域的变量，如需修改，加global关键字，声明变量为全局变量

y = 10
def fun():
	global y
	y = 5
	print(y) # 5
fun()
print(y) # 5

5.4 lambda表达式

lambda 并不会带来程序运行效率的提高，只会使代码更简洁
如果可以使用for…in…if来完成的，坚决不用lambda
如果使用lambda，lambda内不要包含循环，如果有，我宁愿定义函数来完成，使代码获得可重用性和更好的可读性

fun1 = lambda x : x + 1
fun1(2)

# lambda和if结合使用
fun2 = lambda x : x + 1 if x == 1 else 0
fun2(1)
# lambda表示式和for循环结合使用
fun3 = [lambda x : x + j for j in range(5)]
[f(3) for f in fun3]
# lambda表达式的嵌套使用
fun4 = lambda : lambda x : x + 5
fun5 = fun4()
fun5(2)
# lambda表达式和map函数结合使用
list1 = list(map(lambda x : x**2, [1, 2, 3, 4]))
list1
# lambda表达式和filter函数结合使用
list2 = list(filter(lambda x : x < 4, [1, 2, 3, 4, 5]))
list2
# lambda表达式用于pandas
pd_1 = pd.DataFrame([round(np.random.random(),2) for _ in range(5)])

pd_2 = pd_1[0].apply(lambda x : '{:.0%}'.format(x))

总结：lambda 是为了减少单行函数的定义而存在的

5.5 常用内置函数

参考博客：Python 69个内置函数分8类总结，这样记更方便！
类型相关：把入参包装为某种类型，这样的内置函数包括：

1. bool()  #d布尔型 
2. int()  #d整形 
3. str()  #d字符型 
4. tuple() #d元包型 
5. dict() #d字典型
6. list() #d列表型 
7. zip() #可迭代对象聚合，(,) 
8. complex() #d复数型 
9. float() #d浮点型
10. bytes() #d字节型数组 
11. bytearray() #d字数数组 
12. range() #d不可更改的序列 
13. object()#d无属性的根类 
14. set() # 集合类型 
15. frozenset() # 冻结集合类型，不允许修改 
16. slice() # 返回一个slice对象，其中start, stop, step等都是只读的

数理统计相关

1.abs() #d绝对值
2.min() #d最小
3.max() #d最大
4.sum() #d求和
5.pow() #d求次幂
6.all() #d所有元素为true则为true
7.any() #d至少一个元素为true则为true
8.divmod() #d(商，余数)
9.round() #四舍五入
10.len() #参数元素个数

进制转换

1.chr() #unicode编码
2.ord() #chr()反操作
3.bin() #转化为ob开头的二进制字符
4.hex() #转化为ox开头的十六进制字符
5.ascii() #可打印表示对象，类似于 repr() 
6.oct() # 转化为0o开头的八进制字符

面向对象相关

1.setattr(object, name, value) #为对象设置属性
2.delattr(object, name) # 删除命名的属性
3.getattr(object,name) #获取属性的取值，如果对象无此属性，会抛异常
4.getattr(object,name, 123) #即便无此属性，也不会抛异常，会返回123
5.hasattr(object,name) # 判断name属性是否属于object
6.isinstance(object, classinfo) #判断object是classinfo的实例吗
7.issubclass(class, classinfo) # 判断class是否为classinfo的子类
8.super() #调用父类， 方法
9.property() #特性相关，@property标记为属性
10.type() #返回实例的类型
11.vars() # 返回对象的信息等
12.classmethod() # 转化方法为类方法
13.staticmethod() #方法是静态方法

迭代器相关
next, reversed, iter(), enumerate()这些都是与迭代相关的函数
map函数：map函数的原型为：map(function, iterable, …) ，返回一个迭代器，在每一个可迭代对象的元素上应用function

def f(x):
    return x**2
my = map(f, [1, 2, 3])
for i in my:
    print(i)

排序相关：sorted返回一个排序好的列表

li = [1,-2,4,0]
sorted(li)

其他：compile函数与源码编译相关；memoryview函数与内存视图相关；help查看帮助；dir查看对象的方法和属性

1.hash() # 返回对象的哈希码
2.id() #返回一个对象的标识
3.input()  #与标准输出相关
4.breakpoint() #调试相关
5.exec() #动态执行Python代码
6.callable() #判断对象是否可调用
7.format() #对象格式化

腾讯云开发者社区

腾讯云面向开发者汇聚海量精品云计算使用和开发经验，营造开放的云计算技术生态圈。

更多推荐

Elasticsearch复杂数据类型终极指南：从入门到精通

Elasticsearch作为功能强大的搜索引擎，支持多种复杂数据类型，让开发者能够灵活处理各种结构化和非结构化数据。本文将带你全面了解Elasticsearch中的复杂数据类型，从基础概念到实际应用，助你轻松掌握数据建模的核心技巧。## 内部对象：构建层级化数据结构在Elasticsearch中，对象类型（Object）是最基础的复杂数据类型之一，用于表示具有嵌套关系的数据。例如，我们可

腾讯云开发者社区

终极指南：Flink SQL连接器版本管理从混乱到有序的升级之路

Apache Flink作为流处理领域的佼佼者，其SQL连接器的版本管理一直是开发者面临的核心挑战。本文将系统讲解Flink SQL连接器版本管理的最佳实践，帮助你轻松应对版本兼容性问题，实现从混乱到有序的升级之旅。## 连接器版本管理的常见痛点 😫在Flink应用开发中，连接器版本管理常常让开发者头疼不已。不同版本的连接器可能导致各种兼容性问题，例如API变更、功能差异甚至运行时错误。

腾讯云开发者社区

如何快速搭建Neon无服务器PostgreSQL：面向初学者的完整指南

Neon是一款革命性的无服务器PostgreSQL解决方案，它通过分离存储和计算层，实现了自动扩缩容、类代码式数据库分支以及零级扩展能力。本指南将帮助你从零开始搭建Neon开发环境，体验这款创新数据库的强大功能。## 准备工作：环境要求与依赖项在开始搭建Neon环境前，请确保你的系统满足以下要求：- Linux操作系统（推荐Ubuntu 20.04+或Debian 11+）- Git