Python语法基础

发表于 | 分类于
Python语法基础

前言

推荐文档：https://www.w3school.com.cn/python/index.asp

打印

1
print("Hello, World!")

格式化打印

1
print(f"lineRect {lineRect} wordRect {wordRect}")

注释

1
# print("Hello, World!")

数据类型

基本类型

整数 (int)
用于表示整数值。Python 的整数类型可以表示任意大小的整数。

1
2
a = 10
b = -5

浮点数 (float)
用于表示带小数点的数字。

1
2
x = 3.14
y = -0.001

布尔值 (bool)
只有两个值：True 和 False，用于表示逻辑值。

1
2
is_active = True
is_visible = False

字符串 (str)
用于表示文本数据。字符串是不可变的。

1
2
name = "Alice"
greeting = 'Hello, World!'

复数 (complex)
用于表示复数，形式为 a + bj，其中 a 是实部，b 是虚部。

1
z = 2 + 3j

集合类型

列表 (list)
有序的可变集合，允许重复元素。用方括号 [] 创建。

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

元组 (tuple)
有序的不可变集合，允许重复元素。用圆括号 () 创建。

1
coordinates = (10, 20)

集合 (set)
无序的集合，元素唯一。用大括号 {} 创建。

1
unique_numbers = {1, 2, 3, 4}

字典 (dict)
无序的键值对集合，键唯一。用大括号 {} 创建，键值对用冒号 : 分隔。

1
person = {"name": "Alice", "age": 30}

其他类型

NoneType (None)
表示“无值”或“空值”。None 是 Python 中唯一的 NoneType 类型。

1
result = None

字节 (bytes) 和 字节数组 (bytearray)
用于表示二进制数据。bytes 是不可变的，而 bytearray 是可变的。

1
2
b = b"hello"
ba = bytearray([65, 66, 67])

类型 (type)
表示对象的类型，通常通过 type() 函数获取。

1
t = type(10)  # <class 'int'>

类型转换

Python 提供了多种方法来转换数据类型：

  • 整数转浮点数: float()
  • 浮点数转整数: int()
  • 字符串转整数/浮点数: int(), float()
  • 整数/浮点数转字符串: str()
  • 列表转元组: tuple()
  • 元组转列表: list()
  • 集合转列表: list()
  • 列表转集合: set()
1
2
3
num = 5
float_num = float(num)  # 转换为浮点数
str_num = str(num)      # 转换为字符串

字典

方法

方法 描述
clear() 删除字典中的所有元素
copy() 返回字典的副本
fromkeys() 返回拥有指定键和值的字典
get() 返回指定键的值
items() 返回包含每个键值对的元组的列表
keys() 返回包含字典键的列表
pop() 删除拥有指定键的元素
popitem() 删除最后插入的键值对
setdefault() 返回指定键的值。如果该键不存在，则插入具有指定值的键。
update() 使用指定的键值对字典进行更新
values() 返回字典中所有值的列表

在 Python 中，字典是一种非常灵活的数据结构，可以存储键值对。

要获取字典中的值或操作字典的属性，你可以使用几种不同的方法。

以下是一些常用的方法来获取字典中的属性和操作字典的内容：

获取字典中的值

使用键访问值

你可以使用字典的键来直接访问对应的值：

1
2
3
4
5
my_dict = {"name": "Alice", "age": 30, "city": "New York"}

# 通过键获取值
name = my_dict["name"]
print(name)  # 输出: Alice

使用 get() 方法

get() 方法用于安全地获取字典中的值，如果键不存在，可以返回一个默认值（默认为 None）：

1
2
3
4
5
6
age = my_dict.get("age")
print(age)  # 输出: 30

# 指定默认值
country = my_dict.get("country", "Unknown")
print(country)  # 输出: Unknown

检查键是否存在

使用 in 关键字可以检查一个键是否在字典中：

1
2
3
4
if "name" in my_dict:
    print("键 'name' 存在")
else:
    print("键 'name' 不存在")

获取所有键、值或键值对

获取所有键：使用 keys() 方法

1
2
keys = my_dict.keys()
print(keys)  # 输出: dict_keys(['name', 'age', 'city'])

获取所有值：使用 values() 方法

1
2
values = my_dict.values()
print(values)  # 输出: dict_values(['Alice', 30, 'New York'])

获取所有键值对：使用 items() 方法

1
2
items = my_dict.items()
print(items)  # 输出: dict_items([('name', 'Alice'), ('age', 30), ('city', 'New York')])

遍历字典

你可以遍历字典的键、值或键值对：

遍历键和值

1
2
for key in my_dict:
    print(f"键: {key}, 值: {my_dict[key]}")

遍历键值对

1
2
for key, value in my_dict.items():
    print(f"键: {key}, 值: {value}")

数组

Python中集合类型是没有数组的。

Python 内置的 array 模块提供了一种更高效的数组实现，可以指定元素类型。

但是，它的长度也是动态的，和 list 类似。

1
2
3
4
import array

# 创建一个整型数组
arr = array.array('i', [0] * 10)  # 初始化一个长度为 10 的整型数组

列表

方法

方法 描述
append() 在列表的末尾添加一个元素
clear() 删除列表中的所有元素
copy() 返回列表的副本
count() 返回具有指定值的元素数量。
extend() 将列表元素（或任何可迭代的元素）添加到当前列表的末尾
index() 返回具有指定值的第一个元素的索引
insert() 在指定位置添加元素
pop() 删除指定位置的元素
remove() 删除具有指定值的项目
reverse() 颠倒列表的顺序
sort() 对列表进行排序

列表排序

1
sort_list = sorted(lineList, key=lambda x: x[0])

列表中的高频字符串

你可以使用 Python 中的 collections.Counter 来获取字符串列表中出现最多的字符串及其比例。

以下是一个示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
from collections import Counter

def get_most_common_string_and_ratio(string_array):
    if not string_array:
        return None, 0  # 如果数组为空，返回 None 和 0

    # 统计每个字符串的出现次数
    counter = Counter(string_array)
    
    # 获取出现次数最多的字符串及其次数
    most_common_string, most_common_count = counter.most_common(1)[0]
    
    # 计算总字符串数量
    total_count = len(string_array)
    
    # 计算比例
    ratio = most_common_count / total_count

    return most_common_string, ratio

# 示例
strings = ["apple", "banana", "apple", "orange", "banana", "apple"]
most_common_string, ratio = get_most_common_string_and_ratio(strings)

print(f"出现最多的字符串: {most_common_string}, 比例: {ratio:.2f}")

说明

  1. Counter：Counter 类会生成一个字典，键为字符串，值为对应的出现次数。
  2. most_common：most_common(1) 返回出现次数最多的字符串及其次数。
  3. 比例计算：通过将出现次数除以总字符串数来计算比例。

集合Set

方法

方法 描述
add() 向集合添加元素。
clear() 删除集合中的所有元素。
copy() 返回集合的副本。
difference() 返回包含两个或更多集合之间差异的集合。
difference_update() 删除此集合中也包含在另一个指定集合中的项目。
discard() 删除指定项目。
intersection() 返回为两个其他集合的交集的集合。
intersection_update() 删除此集合中不存在于其他指定集合中的项目。
isdisjoint() 返回两个集合是否有交集。
issubset() 返回另一个集合是否包含此集合。
issuperset() 返回此集合是否包含另一个集合。
pop() 从集合中删除一个元素。
remove() 删除指定元素。
symmetric_difference() 返回具有两组集合的对称差集的集合。
symmetric_difference_update() 插入此集合和另一个集合的对称差集。
union() 返回包含集合并集的集合。
update() 用此集合和其他集合的并集来更新集合。

元组

方法

方法 描述
count() 返回元组中指定值出现的次数。
index() 在元组中搜索指定的值并返回它被找到的位置。

字符串

格式化

基本格式化

我们可以使用 format() 方法对结果进行格式化。

1
2
3
4
name = "Alice"
age = 30
result = "Name: {}, Age: {}".format(name, age)
print(result)  # 输出: Name: Alice, Age: 30

索引号

您可以使用索引号（花括号 {0} 内的数字）来确保将值放在正确的占位符中：

1
2
3
4
5
quantity = 3
itemno = 567
price = 52
myorder = "I want {0} pieces of item number {1} for {2:.2f} dollars."
print(myorder.format(quantity, itemno, price))

此外，如果要多次引用相同的值，请使用索引号：

1
2
3
4
age = 63
name = "Bill"
txt = "His name is {1}. {1} is {0} years old."
print(txt.format(age, name))

命名索引

您还可以通过在花括号 {carname} 中输入名称来使用命名索引，但是在传递参数值 txt.format(carname = “Ford”) 时，必须使用名称：

1
2
myorder = "I have a {carname}, it is a {model}."
print(myorder.format(carname = "Porsche", model = "911"))

其它方法

Python 有一组可以在字符串上使用的内建方法。

注释：所有字符串方法都返回新值。它们不会更改原始字符串。

方法 描述
capitalize() 把首字符转换为大写。
casefold() 把字符串转换为小写。
center() 返回居中的字符串。
count() 返回指定值在字符串中出现的次数。
encode() 返回字符串的编码版本。
endswith() 如果字符串以指定值结尾，则返回 true。
expandtabs() 设置字符串的 tab 尺寸。
find() 在字符串中搜索指定的值并返回它被找到的位置。
format() 格式化字符串中的指定值。
format_map() 格式化字符串中的指定值。
index() 在字符串中搜索指定的值并返回它被找到的位置。
isalnum() 如果字符串中的所有字符都是字母数字，则返回 True。
isalpha() 如果字符串中的所有字符都在字母表中，则返回 True。
isdecimal() 如果字符串中的所有字符都是小数，则返回 True。
isdigit() 如果字符串中的所有字符都是数字，则返回 True。
isidentifier() 如果字符串是标识符，则返回 True。
islower() 如果字符串中的所有字符都是小写，则返回 True。
isnumeric() 如果字符串中的所有字符都是数，则返回 True。
isprintable() 如果字符串中的所有字符都是可打印的，则返回 True。
isspace() 如果字符串中的所有字符都是空白字符，则返回 True。
istitle() 如果字符串遵循标题规则，则返回 True。
isupper() 如果字符串中的所有字符都是大写，则返回 True。
join() 把可迭代对象的元素连接到字符串的末尾。
ljust() 返回字符串的左对齐版本。
lower() 把字符串转换为小写。
lstrip() 返回字符串的左修剪版本。
maketrans() 返回在转换中使用的转换表。
partition() 返回元组，其中的字符串被分为三部分。
replace() 返回字符串，其中指定的值被替换为指定的值。
rfind() 在字符串中搜索指定的值，并返回它被找到的最后位置。
rindex() 在字符串中搜索指定的值，并返回它被找到的最后位置。
rjust() 返回字符串的右对齐版本。
rpartition() 返回元组，其中字符串分为三部分。
rsplit() 在指定的分隔符处拆分字符串，并返回列表。
rstrip() 返回字符串的右边修剪版本。
split() 在指定的分隔符处拆分字符串，并返回列表。
splitlines() 在换行符处拆分字符串并返回列表。
startswith() 如果以指定值开头的字符串，则返回 true。
strip() 返回字符串的剪裁版本。
swapcase() 切换大小写，小写成为大写，反之亦然。
title() 把每个单词的首字符转换为大写。
translate() 返回被转换的字符串。
upper() 把字符串转换为大写。
zfill() 在字符串的开头填充指定数量的 0 值。

是否包含

1
2
3
4
5
6
7
8
# 定义字符串
text = "Hello, world!"

# 判断子字符串是否在主字符串中
if "world" in text:
    print("子字符串 'world' 存在于主字符串中")
else:
    print("子字符串 'world' 不存在于主字符串中")

if else

1
2
3
4
5
6
7
8
a = 200
b = 66
if b > a:
  print("b is greater than a")
elif a == b:
  print("a and b are equal")
else:
  print("a is greater than b")

循环

while循环

在 i 等于 3 时退出循环：

1
2
3
4
5
6
i = 1
while i < 7:
  print(i)
  if i == 3:
    break
  i += 1

for循环

for 循环用于迭代序列（即列表，元组，字典，集合或字符串）。

遍历元素及索引

1
2
3
4
fruits = ["apple", "banana", "cherry"]

for index, fruit in enumerate(fruits):
    print(f"Index: {index}, Fruit: {fruit}")

循环字符串

循环遍历单词 “banana” 中的字母：

1
2
for x in "banana":
  print(x)

循环列表

1
2
3
4
5
fruits = ["apple", "banana", "cherry"]
for x in fruits:
  print(x) 
  if x == "banana":
    break

循环字典

方式1

1
2
3
d = {'name1' : 'pythontab', 'name2' : '.', 'name3' : 'com'}
for key in d:
    print (key, ' value : ', d[key])

方式2

1
2
for key, value in d.items():
    print (key, ' value : ', value)

range函数

range() 函数返回一个数字序列，默认情况下从 0 开始，并递增 1（默认地），并以指定的数字结束。

包含开始不包含结束

使用 range() 函数：

1
2
for x in range(10):
  print(x)

设置开始

1
2
for i in range(3, 8):
    print(i)

迭代器

从元组返回一个迭代器，并打印每个值：

1
2
3
4
5
6
mytuple = ("apple", "banana", "cherry")
myit = iter(mytuple)

print(next(myit))
print(next(myit))
print(next(myit))

创建迭代器

要把对象/类创建为迭代器，必须为对象实现 iter() 和 next() 方法。

正如您在 Python 类/对象 一章中学到的，所有类都有名为 init() 的函数，它允许您在创建对象时进行一些初始化。

  • __iter__() 方法的作用相似，您可以执行操作（初始化等），但必须始终返回迭代器对象本身。

  • __next__() 方法也允许您执行操作，并且必须返回序列中的下一个项目。

创建一个返回数字的迭代器，从 1 开始，每个序列将增加 1（返回 1、2、3、4、5 等）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    x = self.a
    self.a += 1
    return x

myclass = MyNumbers()
myiter = iter(myclass)

print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

StopIteration

如果你有足够的 next() 语句，或者在 for 循环中使用，则上面的例子将永远进行下去。

为了防止迭代永远进行，我们可以使用 StopIteration 语句。

在 next() 方法中，如果迭代完成指定的次数，我们可以添加一个终止条件来引发错误：

在 20 个迭代之后停止：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration

myclass = MyNumbers()
myiter = iter(myclass)

for x in myiter:
  print(x)

函数

1
2
3
4
def my_function():
  print("Hello from a function")

my_function()

Lambda

1
2
x = lambda a, b, c : a + b + c
print(x(5, 6, 2))

异常

try 块将生成异常，因为 x 未定义：

1
2
3
4
try:
  print(x)
except:
  print("An exception occurred")

多个异常

您可以根据需要定义任意数量的 exception 块，例如，假如您要为特殊类型的错误执行特殊代码块：

如果 try 块引发 NameError，则打印一条消息，如果是其他错误则打印另一条消息：

1
2
3
4
5
6
try:
  print(x)
except NameError:
  print("Variable x is not defined")
except:
  print("Something else went wrong")

Else

如果没有引发错误，那么您可以使用 else 关键字来定义要执行的代码块：

在本例中，try 块不会生成任何错误：

1
2
3
4
5
6
try:
  print("Hello")
except:
  print("Something went wrong")
else:
  print("Nothing went wrong")

Finally

如果指定了 finally 块，则无论 try 块是否引发错误，都会执行 finally 块。

1
2
3
4
5
6
try:
  print(x)
except:
  print("Something went wrong")
finally:
  print("The 'try except' is finished")

with

1
2
3
4
5
6
7
8
9
10
11
try:
    f = open('xxx')
except:
    print('fail to open')
    exit(-1)
try:
    do something
except:
    do something
finally:
    f.close()

虽然这段代码运行良好，但比较冗长。
而使用with的话，能够减少冗长，还能自动处理上下文环境产生的异常。如下面代码：

1
2
with open("1.txt") as file:
    data = file.read()

with 工作原理

（１）紧跟with后面的语句被求值后，返回对象的__enter__()方法被调用，这个方法的返回值将被赋值给as后面的变量；
（２）当with后面的代码块全部被执行完之后，将调用前面返回对象的__exit__()方法。
with工作原理代码示例：

1
2
3
4
5
6
7
8
9
10
class Sample:
    def __enter__(self):
        print "in __enter__"
        return "Foo"
    def __exit__(self, exc_type, exc_val, exc_tb):
        print "in __exit__"
def get_sample():
    return Sample()
with get_sample() as sample:
    print "Sample: ",

代码的运行结果如下：

1
2
3
in __enter__
Sample:  Foo
in __exit__

可以看到，整个运行过程如下：
（１）enter()方法被执行；
（２）enter()方法的返回值，在这个例子中是”Foo”，赋值给变量sample；
（３）执行代码块，打印sample变量的值为”Foo”；
（４）exit()方法被调用；

exit()方法中有３个参数， exc_type, exc_val, exc_tb，这些参数在异常处理中相当有用。

  • exc_type：　错误的类型
  • exc_val：　错误类型对应的值
  • exc_tb：　代码中错误发生的位置

日期

1
2
3
4
5
6
7
8
import datetime

x = datetime.datetime(2020, 5, 17)

print(x)

y = datetime.datetime.now()
print(y)

JSON

字符串转对象

1
2
3
4
5
6
7
8
9
10
import json

# 一些 JSON:
x =  '{ "name":"Bill", "age":63, "city":"Seatle"}'

# 解析 x:
y = json.loads(x)

# 结果是 Python 字典：
print(y["age"])

对象转字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import json

# Python 对象（字典）：
x = {
  "name": "Bill",
  "age": 63,
  "city": "Seatle"
}

# 转换为 JSON：
y = json.dumps(x)

# 结果是 JSON 字符串：
print(y)

当 Python 转换为 JSON 时，Python 对象会被转换为 JSON（JavaScript）等效项：

Python JSON
dict Object
list Array
tuple Array
str String
int Number
float Number
True true
False false
None null

模块

在名为 mymodule.py 的文件中保存代码：

1
2
def greeting(name):
  print("Hello, " + name)

导入名为 mymodule 的模块，并调用 greeting 函数：

1
2
3
import mymodule

mymodule.greeting("Bill")