Eric Matthes_Python编程从入门到实践 + 补充(笔记)

---

---

前言

Eric Matthes ; C语言中文网 ; 菜鸟教程 ; Python ; 笔记

---

---

一、变量类型和运算符

1.字符串

 1. `字符串`
 2. "字符串"
 3. '''长字符串, 也可以当做注释'''
 4. r'原始字符串' # 字符串前追加r, 不以特殊方式处理转义字符 \ ,最后一个字符不能为 \

---

---

二、字符串常用方法

1.字符串拼接

1).紧挨

2). ‘+’

3).字符串与数字拼接

数据类型转换 :
str(obj)
repr(obj)

name = "sugar"
age = 22
info = name + "已经" + str(age) + "岁了"
print(info)

2.字符串切片

3.字符串长度_len()函数

4.字符串分割_split()函数

5.字符串合并_join()函数

6.字符串统计_count()函数

7.检测子串_find()函数

8.检测子串_index()方法

9.字符串对齐_ljust()_rjust_center()方法

10. 判断字符串_开头/结尾_startswith()_endswith()方法

11. 字符串大小写转换_

12.去除字符串中空格（删除指定字符）

13.字符串编码转换_encode()_decode()方法

---

---

三、列表与列表的操作

1.序列

Python 中，序列类型包括 : 字符串、列表、元组、集合和字典，
这些序列支持以下几种通用的操作，
但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。

1). 序列索引

2). 序列切片

3). 序列相加

4). 序列相乘

5). 检查元素是否包含在序列中

 in / not in  关键字 :
 value in sequence # 返回 True / False

6). 序列的内置函数

函数	功能
len()	计算序列的长度，即返回序列中包含多少个元素
max()	找出序列中的最大元素
min()	找出序列中的最小元素
list()	将序列转换为列表
str()	将序列转换为字符串
sum()	计算元素和。
sorted()	对元素进行排序
reversed()	反向序列中的元素
enumerate()	将序列组合为一个索引序列，多用在 for 循环中

2.列表

1. 给列表指定一个复数的名称
2. 输出时, 可使用 title() 方法, 首字母大写
3. 索引从 0 开始, -1返回最后一个列表元素
4. 索引返回的值(字符串), 不包含 
5. 方括号和引号
6. 可以像其他变量一样使用列表中的各个值

1). [ ] 直接创建列表

emptylist = [ ] // 列表中元素可以有多个，也可以一个都没有

2). list() 函数创建列表

将其它数据类型转换为列表类型

#将字符串转换成列表
list1 = list("hello")

print(list1)
#将元组转换成列表
tuple1 = ('Python', 'Java', 'C++')
list2 = list(tuple1)
print(list2)

#将字典转换成列表
dict1 = {'a':100, 'b':50, 'c':20}
list3 = list(dict1)
print(list3)

#将区间转换成列表
range1 = range(1, 6)
list4 = list(range1)
print(list4)

#创建空列表
print(list())

'''
运行结果 :
['h', 'e', 'l', 'l', 'o']
['Python', 'Java', 'C++']
['a', 'b', 'c']
[1, 2, 3, 4, 5]
[]
'''

3). 访问列表元素

1. listname[i]
2. listname[start : end : step]

4). 删除列表

1. del listname
2. Python 自动销毁无用的列表

2.列表添加元素

1).+ 运算符将多个序列连接

列表的末尾添加了另一个列表

language = ["Python", "C++", "Java"]
birthday = [1991, 1998, 1995]

info = language + birthday

print("language =", language)
print("birthday =", birthday)
print("info =", info)

'''
运行结果 : 
language = ['Python', 'C++', 'Java']
birthday = [1991, 1998, 1995]
info = ['Python', 'C++', 'Java', 1991, 1998, 1995]
'''

2).append()方法 _视为整体

listname.append(obj)

l = ['Python', 'C++', 'Java']
#追加元素
l.append('PHP')
print(l)

#追加元组，整个元组被当成一个元素
t = ('JavaScript', 'C#', 'Go')
l.append(t)
print(l)

#追加列表，整个列表也被当成一个元素
l.append(['Ruby', 'SQL'])
print(l)

'''

['Python', 'C++', 'Java', 'PHP']
['Python', 'C++', 'Java', 'PHP', ('JavaScript', 'C#', 'Go')]
['Python', 'C++', 'Java', 'PHP', ('JavaScript', 'C#', 'Go'), ['Ruby', 'SQL']]
'''

3).extend()方法 _视为元素

listname.extend(obj) # 不能添加单个数字

l = ['Python', 'C++', 'Java']

#追加元素
l.extend('C')
print(l)

#追加元组，元祖被拆分成多个元素
t = ('JavaScript', 'C#', 'Go')
l.extend(t)
print(l)

#追加列表，列表也被拆分成多个元素
l.extend(['Ruby', 'SQL'])
print(l)

'''
运行结果 :
['Python', 'C++', 'Java', 'C']
['Python', 'C++', 'Java', 'C', 'JavaScript', 'C#', 'Go']
['Python', 'C++', 'Java', 'C', 'JavaScript', 'C#', 'Go', 'Ruby', 'SQL']
'''

4).insert()方法 _视为整体

listname.insert(index , obj)

l = ['Python', 'C++', 'Java']

#插入元素
l.insert(1, 'C')
print(l)

#插入元组，整个元祖被当成一个元素
t = ('C#', 'Go')
l.insert(2, t)
print(l)

#插入列表，整个列表被当成一个元素
l.insert(3, ['Ruby', 'SQL'])
print(l)

#插入字符串，整个字符串被当成一个元素
l.insert(0, "http://c.biancheng.net")
print(l)

'''
['Python', 'C', 'C++', 'Java']
['Python', 'C', ('C#', 'Go'), 'C++', 'Java']
['Python', 'C', ('C#', 'Go'), ['Ruby', 'SQL'], 'C++', 'Java']
['http://c.biancheng.net', 'Python', 'C', ('C#', 'Go'), ['Ruby', 'SQL'], 'C++', 'Java']
'''

3.列表删除元素

1).del_ 根据索引值删除元素

1. del listname[index]
2. del listname[start : end]

lang = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]

#使用正数索引
del lang[2]
print(lang)

#使用负数索引
del lang[-2]
print(lang)

'''
运行结果 :
['Python', 'C++', 'PHP', 'Ruby', 'MATLAB']
['Python', 'C++', 'PHP', 'MATLAB']
'''

lang = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]

del lang[1: 4] #[1]删, [4]不删
print(lang)

lang.extend(["SQL", "C#", "Go"])
print(lang)

del lang[-5: -2] #[-5]删, [-2]不删
print(lang)

'''
运行结果 :
['Python', 'Ruby', 'MATLAB']
['Python', 'Ruby', 'MATLAB', 'SQL', 'C#', 'Go']
['Python', 'C#', 'Go']
'''

2).pop()_ 根据索引值删除元素

listname.pop(index) :
listname 表示列表名称，index 表示索引值。
如果不写 index 参数，默认会删除列表中的最后一个元素，类似于数据结构中的“出栈”操作

nums = [40, 36, 89, 2, 36, 100, 7]

nums.pop(3)
print(nums)

nums.pop()
print(nums)

'''
运行结果 :
[40, 36, 89, 36, 100, 7]
[40, 36, 89, 36, 100]
'''

3).remove()_ 根据元素值进行删除

remove() 方法只会删除第一个和指定值相同的元素，
而且必须保证该元素是存在的，否则会引发 ValueError 错误。

nums = [40, 36, 89, 2, 36, 100, 7]

#第一次删除36
nums.remove(36)

print(nums)

#第二次删除36
nums.remove(36)
print(nums)

#删除78
nums.remove(78) # 该元不存在，引发 ValueError 错误
print(nums) 
'''
运行结果 :
[40, 89, 2, 36, 100, 7]
[40, 89, 2, 100, 7]
Traceback (most recent call last):
  File "/home/sugar/test.py", line 13, in <module>
    nums.remove(78)
ValueError: list.remove(x): x not in list
'''

4).clear()_ 删除列表所有元素

url = list("Hello World")

url.clear()

print(url)

'''
运行结果 :
[]
'''

4.列表修改元素

1).修改单个元素

nums = [40, 36, 89, 2, 36, 100, 7]

nums[2] = -26  #使用正数索引
print(nums)

nums[-3] = -66.2  #使用负数索引
print(nums)

'''
运行结果 :
[40, 36, -26, 2, 36, 100, 7]
[40, 36, -26, 2, -66.2, 100, 7]
'''

2).修改一组元素

Python 支持通过切片语法给一组元素赋值。
在进行这种操作时，如果不指定步长（step 参数），Python 就不要求新赋值的元素个数与原来的元素个数相同；
这意味，该操作既可以为列表添加元素，也可以为列表删除元素。

nums = [40, 36, 89, 2, 36, 100, 7]

#修改第 1~4 个元素的值（不包括第4个元素）
nums[1: 4] = [45.25, -77, -52.5]
print(nums)

'''
运行结果 :
[40, 45.25, -77, -52.5, 36, 100, 7]
'''

nums = [40, 36, 89, 2, 36, 100, 7]

#在4个位置插入元素_ 相当于插入一组新元素
nums[4: 4] = [-77, -52.5, 999] #在[4]前插入
print(nums)

'''
运行结果 :
[40, 45.25, -77, -52.5, 36, 100, 7]
'''

4.列表查找元素

5.range()_快速初始化数字列表

6.列表实现栈和队列

---

---

三、元组

1.创建元组

2.访问元组元素

3.修改元组

4.删除元组

5.元组与列表的区别

6.元组与列表的底层实现

---

---

四、集合

1.创建集合

2.访问集合元素

3.删除集合

4.集合操作_ 添加、删除、交集、并集、差集

5.集合方法

方法名	语法格式	功能	实例
add()	right-aligned 文本居右	向 set1 集合中添加数字、字符串、元组或者布尔类型	right-aligned 文本居右
clear()	right-aligned 文本居右	清空 set1 集合中所有元素	right-aligned 文本居右
copy()	right-aligned 文本居右	right-aligned 文本居右	right-aligned 文本居右
difference()	right-aligned 文本居右	right-aligned 文本居右	right-aligned 文本居右
difference_update()	right-aligned 文本居右	right-aligned 文本居右	right-aligned 文本居右
discard()	right-aligned 文本居右	right-aligned 文本居右	right-aligned 文本居右
intersection()	right-aligned 文本居右	right-aligned 文本居右	right-aligned 文本居右
intersection_update()	right-aligned 文本居右	right-aligned 文本居右	right-aligned 文本居右
isdisjoint()	right-aligned 文本居右	right-aligned 文本居右	right-aligned 文本居右
issubset()	right-aligned 文本居右	right-aligned 文本居右	right-aligned 文本居右
issuperset()	right-aligned 文本居右	right-aligned 文本居右	right-aligned 文本居右
pop()	right-aligned 文本居右	right-aligned 文本居右	right-aligned 文本居右
remove()	right-aligned 文本居右	right-aligned 文本居右	right-aligned 文本居右
symmetric_difference()	right-aligned 文本居右	right-aligned 文本居右	right-aligned 文本居右
symmetric_difference_update()	right-aligned 文本居右	right-aligned 文本居右	right-aligned 文本居右
union()	right-aligned 文本居右	right-aligned 文本居右	right-aligned 文本居右
intersection_update()	right-aligned 文本居右	right-aligned 文本居右	right-aligned 文本居右
update()	right-aligned 文本居右	right-aligned 文本居右	right-aligned 文本居右

6.frozenset集合

---

---

五、字典

1.字典与基本操作

表示形式 : dict = {’ ’ : ’ ', ’ ’ : ’ ', }
键和值之间用冒号分隔, 键-值对直接用逗号分隔, 可将任何对象用作字典中的值

1).创建一个空字典

dict = { }

2).添加键-值对

dict['color'] = 'red'

3).删除键-值对

del 字典名[键名]

del dict['color']

4).修改字典中的值

字典名[键名] = ‘新值’

dict = { }
dict['color'] = 'red'   # 字典中没有则新建
dict['color'] = 'white' # 字典中有则修改

5).访问字典中的值

字典名[键名]

6).遍历所有的键-值对

字典名.items()
返回一个键-值对列表

# for k, v in dict.items():
for key,value in dict.items():
	print("\nKey: " + key)
	print("Value: " + value)

7).遍历字典中的所有键

字典名.key()

for key in dict.key():
# for key in dict:

8).按顺序遍历字典中的所有键

sorted() # 获得特定顺序排列的列表 的 副本

for key in sorted(dict.key()):

9).遍历字典中的所有值

字典名.values()
set() # 集合, 剔除重复项

for value in set(dict.value()):
# for value in dict.value():

2.创建字典

3.访问字典

4.删除字典

---

5.嵌套

1.列表中存储字典

2.字典中存储列表

3.字典中存储字典

---

---

六、流程控制

1.循环

2.条件判断

---

---

七、函数

---

---

八、错误和异常

1.语法错误

语法错误
Python 的语法错误或者称之为解析错，是初学者经常碰到的，如下实例
这个例子中，函数 print() 被检查到有错误，是它前面缺少了一个冒号 : 。

语法分析器指出了出错的一行，并且在最先找到的错误的位置标记了一个小小的箭头。

>>> while True print('Hello world')
  File "<stdin>", line 1, in ?
    while True print('Hello world')
                   ^
SyntaxError: invalid syntax

2.异常

即便 Python 程序的语法是正确的，在运行它的时候，也有可能发生错误。
运行期检测到的错误被称为异常。

大多数的异常都不会被程序处理，都以错误信息的形式展现在这里:
异常以不同的类型出现，这些类型都作为信息的一部分打印出来: 
例子中的类型有 ZeroDivisionError，NameError 和 TypeError。

错误信息的前面部分显示了异常发生的上下文，并以调用栈的形式显示具体信息。

>>> 10 * (1/0)             # 0 不能作为除数，触发异常
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ZeroDivisionError: division by zero
>>> 4 + spam*3             # spam 未定义，触发异常
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
NameError: name 'spam' is not defined
>>> '2' + 2               # int 不能与 str 相加，触发异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str

3.异常处理

1).Try…Except

try 语句按照如下方式工作；

首先，执行 try 子句（在关键字 try 和关键字 except 之间的语句）。

如果没有异常发生，忽略 except 子句，try 子句执行后结束。

如果在执行 try 子句的过程中发生了异常，那么 try 子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的 except 子句将被执行。

如果一个异常没有与任何的 except 匹配，那么这个异常将会传递给上层的 try 中。

一个 try 语句可能包含多个except子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。

处理程序将只针对对应的 try 子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。

最后一个except子句可以忽略异常的名称，它将被当作通配符使用。你可以使用这种方法打印一个错误信息，然后再次把异常抛出。

try/except 语句还有一个可选的 else 子句，如果使用这个子句，那么必须放在所有的 except 子句之后。

else 子句将在 try 子句没有发生任何异常的时候执行。

mport sys

try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err:
    print("OS error: {0}".format(err))
except ValueError:
    print("Could not convert data to an integer.")
except:
    print("Unexpected error:", sys.exc_info()[0])
    raise

一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组，例如:

except (RuntimeError, TypeError, NameError):
    pass

使用 else 子句比把所有的语句都放在 try 子句里面要好，
这样可以避免一些意想不到，而 except 又无法捕获的异常。
以下实例在 try 语句中判断文件是否可以打开，如果打开文件时正常的没有发生异常则执行 else 部分的语句，读取文件内容：

2).Try…Except…Else

for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except IOError:
        print('cannot open', arg)
    else:
        print(arg, 'has', len(f.readlines()), 'lines')
        f.close()

异常处理并不仅仅处理那些直接发生在 try 子句中的异常，
而且还能处理子句中调用的函数（甚至间接调用的函数）里抛出的异常。例如:

>>> def this_fails():
        x = 1/0
   
>>> try:
        this_fails()
    except ZeroDivisionError as err:
        print('Handling run-time error:', err)
   
Handling run-time error: int division or modulo by zero

3).Try…Except…Else…Finally

try-finally 语句无论是否发生异常都将执行最后的代码。

try:
    runoob()
except AssertionError as error:
    print(error)
else:
    try:
        with open('file.log') as file:
            read_data = file.read()
    except FileNotFoundError as fnf_error:
        print(fnf_error)
finally:
    print('这句话，无论异常是否发生都会执行。')

4.抛出异常_raise

Python 使用 raise 语句抛出一个指定的异常。

raise语法格式如下：

raise [Exception [, args [, traceback]]]

以下实例如果 x 大于 5 就触发异常:

x = 10
if x > 5:
    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))
# 执行以上代码会触发异常：
'''
Traceback (most recent call last):
  File "test.py", line 3, in <module>
    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))
Exception: x 不能大于 5。x 的值为: 10
'''

5.用户自定义异常

1).

raise 唯一的一个参数指定了要被抛出的异常。
它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。

如果你只想知道这是否抛出了一个异常，
并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。

class MyError(Exception):
        def __init__(self, value):
            self.value = value
        def __str__(self):
            return repr(self.value)

try:
    raise MyError(2*2)
except MyError as e:
     print('My exception occurred, value:', e.value)

raise MyError('oops!')

'''
My exception occurred, value: 4
Traceback (most recent call last):
  File "/home/sugar/test.py", line 12, in <module>
    raise MyError('oops!')
__main__.MyError: 'oops!'
'''

2).一个模块有抛出多种不同的异常

大多数的异常的名字都以"Error"结尾，就跟标准的异常命名一样。
当创建一个模块有可能抛出多种不同的异常时，一种通常的做法是为这个包建立一个基础异常类
，然后基于这个基础类为不同的错误情况创建不同的子类:

class Error(Exception):
    """Base class for exceptions in this module."""
    pass

class InputError(Error):
    """Exception raised for errors in the input.

    Attributes:
        expression -- input expression in which the error occurred
        message -- explanation of the error
    """

    def __init__(self, expression, message):
        self.expression = expression
        self.message = message

class TransitionError(Error):
    """Raised when an operation attempts a state transition that's not
    allowed.

    Attributes:
        previous -- state at beginning of transition
        next -- attempted new state
        message -- explanation of why the specific transition is not allowed
    """

    def __init__(self, previous, next, message):
        self.previous = previous
        self.next = next
        self.message = message

九、文件

1.open() 方法

2.mode 参数

3.file 对象

九、输入与输出

1.f-string（格式化字符串字面值）

f-string（格式化字符串字面值）是 Python 3.6+ 引入的一种方便的字符串格式化方法。
它提供了一种简洁、直观和易于使用的方式来插入变量值和表达式到字符串中。

以下是在开发中常用的几种 f-string 用法：

1).插入变量值

name = "Alice"
age = 25
print(f"My name is {name} and I am {age} years old.")

'''
运行结果 :
My name is Alice and I am 25 years old.
'''

2).执行表达式

x = 5
y = 10
print(f"The sum of {x} and {y} is {x + y}.")
The sum of 5 and 10 is 15.
'''
运行结果 :

'''

3).格式化数字

pi = 3.1415926
print(f"The value of pi is approximately {pi:.2f}.")
# 输出: The value of pi is approximately 3.14.

4).使用字典和列表

person = {"name": "Alice", "age": 25}
print(f"Name: {person['name']}, Age: {person['age']}")
# 输出: Name: Alice, Age: 25

numbers = [1, 2, 3, 4, 5]
print(f"The first three numbers are: {numbers[:3]}")
# 输出: The first three numbers are: [1, 2, 3]

5).调用方法

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

    def say_hello(self):
        return f"Hello, my name is {self.name}."

person = Person("Alice", 25)
print(person.say_hello())

6).常见示例

1. 控制小数位数

pi = 3.1415926
print(f"Pi value: {pi:.2f}")  # 输出: Pi value: 3.14

2. 指定字符串宽度和对齐方式：

name = "Alice"
age = 25
# 将变量 name 格式化为一个宽度为 10 的左对齐字符串
# 将变量 age  格式化为一个宽度为 4  的右对齐字符串。
print(f"Name: {name:<10} Age: {age:4}")  # 输出: Name: Alice      Age:   25

3. 格式化日期和时间：

from datetime import datetime
now = datetime.now()
# +8 时区
print(f"Current time: {now:%Y-%m-%d %H:%M:%S}")  # 输出: Current time: 2023-07-06 06:40:39

4. 格式化数值的千位分隔符：

population = 1000000
print(f"Population: {population:,}")  # 输出: Population: 1,000,000

5. 控制整数位数和填充字符

num = 42
print(f"Number: {num:04}")  # 输出: Number: 0042

7. 控制科学计数法显示

value = 1.2345e-6
print(f"Value: {value:.2e}")  # 输出: Value: 1.23e-06

8. 控制字符串截断和省略号

text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit."
print(f"Text: {text[:20]}...")  # 输出: Text: Lorem ipsum dolor si...

9. 格式化布尔值

is_true = True
#在 {is_true!s} 中，!s 表示使用字符串形式输出布尔值。
#在 {is_true!r} 中，!r 表示使用表示形式输出布尔值。
print(f"Flag: {is_true!s}")  # 输出: Flag: True
print(f"Flag: {is_true!r}")  # 输出: Flag: True

---

---

十、类

编程实践

1.基本输入输出函数

input()
eval()
print()_ format()

1).

键盘输入字符串s，按要求把s输出到屏幕，
格式要求:宽度为30个字符，星号字符*填充，居中对齐。如果输入字符串超过30位，则全部输出。

// 考生文件初始代码
s = input("请输入一个字符串:")
print("{______}".format(s))

// 参考答案
s = input("请输入一个字符串:")
print("{:*^30}".format(s))

1).

1).

1).

2.程序的控制结构和数据类型

顺序结构
分支结构
循环结构
程序的异常处理

基本数据类型_字符串
组合数据类型_ 列表

3.Python计算生态

jieba库(中文分词)
random
turtle
time
python常用内置函数

4.Python文件操作

打开文件
读取文件
写文件
关闭文件

读取考生文件夹下的“poem.txt"的内容，去除空行和注释行后，以行为单位进行排序，并将结果输出到屏幕上。输出结果为:
A Grain of Sand
And a heaven in a wild flower,
And eternity in an hour.
Hold infinity in the palm of your hand,
To see a world in a grain of sand,

5.简单应用题与综合应用题

---

补充

1.__name__属性

一个模块被另一个程序第一次引入时，其主程序将运行。
#!/usr/bin/python3
# Filename: using_name.py

if __name__ == '__main__':
   print('程序自身在运行')

在 Python 中，`if __name__ == '__main__':` 是一个常见的代码块，
通常用于确定当前脚本是直接被执行还是作为模块被导入。

当一个 Python 脚本文件被直接执行时，`__name__` 的值会被设置为 `'__main__'`，
表示当前模块是主程序入口。这时，可以在 `if __name__ == '__main__':` 下编写一些希望在直接执行脚本时执行的代码。

举个例子，假设有一个名为 `example.py` 的脚本文件，其中包含以下代码：

def say_hello():
    print("Hello, World!")

if __name__ == '__main__':
    say_hello()

当直接执行 `example.py` 文件时，`say_hello()` 函数会被调用并打印出 `"Hello, World!"`。
然而，如果 `example.py` 文件被作为模块导入到其他脚本中使用时，`say_hello()` 函数不会被自动调用，
因为此时 `__name__` 的值会被设置为模块的名称。

通过使用 `if __name__ == '__main__':`，可以在脚本中同时包含可执行的代码和可作为模块导入的代码，
提高了脚本的可重用性和模块化程度。

2.Time库

1).time.time()

#!/usr/bin/python3

import datetime
import time  # 引入time模块

ticks = time.time()
print ("当前时间戳为:", ticks)

time.sleep(3)

print("当前 '+8' 时区的时间", datetime.datetime.now())

time.sleep(3)
'''
前时间戳为: 1688627183.542973
当前 '+8' 时区的时间 2023-07-06 07:06:26.546149
'''
'''

2).time.sleep()

time.sleep(number)

3.JSON

1).dumps()

import json

data = {'name': 'John', 'age': 30}
json_str = json.dumps(data)
print(json_str)  # 输出 JSON 字符串 {"name": "John", "age": 30}

2).loads()

4.repr()

5.format()

位置形式：
 print("{0}、{1}、{2}").format("apple", "banana", "orange")，输出结果为 "apple、banana、orange"。
关键字形式：
print("{name}: {age}岁").format(name="Tom", age=20)，输出结果为 "Tom: 20岁"。
格式化字符串形式：
 print("%s %s" % ("apple", "banana"))，输出结果为 "apple banana"。
format() 方法形式：
使用 format() 方法来插入变量的值，例如 print("{} {}".format("apple", "banana"))，输出结果为 "apple banana"。
f-string形式：
使用 f-string 来插入变量的值，例如 print(f"我的名字是{name}，年龄是{age}岁")，其中 name 和 age 是变量名。

1).对齐

2).定长

3).填充

5.jieba分词

---

总结

23/06/27 - 未完结