JZTXT

Python学习记录

发布时间 2024-01-04 18:22:55作者: 极致猎手

PYTHON学习记录

Python3源码文件默认以UTF-8编码，所有字符串都是unicode字符串。

导入库

将整个模块(somemodule)导入：import somemodule
从某个模块中导入某个函数：	from somemodule import somefunction
从某个模块中导入多个函数：	from somemodule import firstfunc,secondfunc,thirdfunc
将某个模块中的全部函数导入：	from somemodule import \*

基本数据类型

赋值:

  • 单个变量赋值

    counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "runoob"     # 字符串

  • 多个变量赋值

    # 法一：
a = b = c = 1
# 法二：
a, b, c = 1, 2, "runoob"

number

  • 整型：int
    1. bool（int 的子类）
  • 浮点数类型：float
  • 复数类型：complex

string

  • 用 单引号 或 双引号 或 三引号（允许跨行输入） 括起来

截取

语法：

  • 变量[下标]
  • 变量[开始向后:开始向前] [向后:向前) 区间为 左闭右开 区间
  • 变量[开始向后:开始向前:步进值]
str = 'Runoob'
print (str)          # 输出字符串
print (str[0:-1])    # 输出第一个到倒数第二个的所有字符
print (str[0])       # 输出字符串第一个字符
print (str[2:5])     # 输出从第三个开始到第五个的字符
print (str[2:])      # 输出从第三个开始的后的所有字符

多次输出

print (str * 2)
print (2 * str)

连接

  • 连接字符串
print (str + "TEST")
  • 连接变量或表达式

  1. f-string形式（Python 3.6及以上版本）【最直观、易读、性能最好】：

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

    在字符串前加上 'f' 的语法，然后在字符串中使用花括号 {} 插入变量。

  2. %格式化字符串形式【老的代码】：

    pythonname = "Bob"
age = 30
message = "My name is %s and I am %d years old." % (name, age)
print(message)

    %s 表示字符串格式，%d 表示整数格式，然后在字符串末尾使用 % 运算符和元组进行格式化。

  3. 逗号加变量形式【打印到控制台常用】：

    pythonname = "Charlie"
age = 22
print("My name is", name, "and I am", age, "years old.")

    使用了逗号来将字符串和变量分开，它们会被自动以空格连接在一起。

更多string内置函数：

[Python3 字符串 | 菜鸟教程 (runoob.com)](https://www.runoob.com/python3/python3-string.html)

list（可变、有序）

  • 列表中元素的类型可以不相同，支持：数字、字符串、列表（就是嵌套）。
列表截取语法：变量[从0开始像后:从-1开始向前]
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
print (list)            # 输出完整列表
print (list[0])         # 输出列表第一个元素
print (list[1:3])       # 从第二个开始输出到第三个元素
print (list[2:])        # 输出从第三个元素开始的所有元素

添加元素到列表

# 创建一个空列表
my_list = []
my_list1 = [40,50]
# 使用append方法在列表末尾添加元素
my_list.append(10)
my_list.append(20)
my_list.append(30)

 - 使用append方法在列表末尾添加整体列表
my_list.append(my_list1)
 - 使用extend方法在列表末尾添加拆散列表
my_list.extend(my_list1)

# 输出: [10, 20, 30, [40, 50], 40, 50]
print(my_list)

删除列表中的元素

  1. del 语句【通用的删除方式，根据索引删除元素 或 删除整个列表】：

    • 功能：del 语句用于删除列表中指定索引位置的元素或删除整个列表。

    • 语法：del list_name[index] 或 del list_name。

    • 示例：

      pythonmy_list = [10, 20, 30, 40, 50]
del my_list[2]  # 删除索引为2的元素（值为30）
# 输出: [10, 20, 40, 50]
print(my_list)

del my_list  # 删除整个列表
# NameError: name 'my_list' is not defined（此时my_list已不存在）

  2. remove 方法【根据值删除第一个匹配的元素】：

    • 功能：remove 方法用于根据值删除列表中的元素，仅删除第一个匹配的元素。

    • 语法：list_name.remove(value)。

    • 示例：

      pythonmy_list = [10, 20, 30, 20, 40, 50]
my_list.remove(20)  # 删除值为20的元素（仅删除第一个匹配的元素）
# 输出: [10, 30, 20, 40, 50]
print(my_list)

  3. pop 方法【删除指定索引位置的元素，返回该元素的值】：

    • 功能：pop 方法用于删除指定索引位置的元素，并返回该元素的值。

    • 语法：list_name.pop(index)。

    • 示例：

      pythonmy_list = [10, 20, 30, 40, 50]
popped_element = my_list.pop(2)  # 删除索引为2的元素（值为30）并返回该值
# 输出: 30
print(popped_element)
# 输出: [10, 20, 40, 50]
print(my_list)

更多list内置函数：

[Python3 列表 | 菜鸟教程 (runoob.com)](https://www.runoob.com/python3/python3-list.html)

tuple（不可变、有序）

  • 与字符串和列表一样，元组也可以被索引、切片、使用+操作符进行拼接。

  • 构造包含 0 或 1 个元素的元组的特殊语法规则：

    tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

添加元素到元组

创建一个新的元组，包含原有元组的内容以及要添加的新元素。

my_tuple = (1, 2, 3)  # 原始元组

element = 4  # 要添加的新元素

# 创建一个新的元组，包含原始元组的内容以及新元素
new_tuple = my_tuple + (element,)

# 输出: (1, 2, 3, 4)
print(new_tuple)

删除元组中的元素

创建一个新的元组，排除你想要删除的元素。

my_tuple = (1, 2, 3, 4, 5)  # 原始元组

# 创建一个新的元组，排除值为2的元素
new_tuple = tuple(x for x in my_tuple if x != 2)

# 输出: (1, 3, 4, 5)
print(new_tuple)

更多tuple内置函数：

[Python3 元组 | 菜鸟教程 (runoob.com)](https://www.runoob.com/python3/python3-tuple.html)

dictionary（键值对）

dict = {}				  # 创建空字典

tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值
print (tinydict.items())  # 输出所有的项

添加元素到字典

如果键不存在，则添加新元素；如果键已经存在，则更新对应的值。

pythonmy_dict = {'a': 1, 'b': 2, 'c': 3}  # 原始字典

# 添加新元素或更新已存在的元素
my_dict['d'] = 4

# 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}
print(my_dict)

删除字典中的元素：

  • del方法【通用的删除方式，根据指定键删除键值对】:
pythonmy_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4}  # 原始字典

# 使用 del 语句删除指定键的元素
del my_dict['b']

# 输出: {'a': 1, 'c': 3, 'd': 4}
print(my_dict)
  • pop() 方法【删除指定键的键值对，返回该键的值】：
pythonmy_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4}  # 原始字典

# 使用 pop() 方法删除指定键的元素，并返回其值
popped_value = my_dict.pop('b')

# 输出: 2
print(popped_value)
# 输出: {'a': 1, 'c': 3, 'd': 4}
print(my_dict)

更多dictionary内置函数：

[Python3 字典 | 菜鸟教程 (runoob.com)](https://www.runoob.com/python3/python3-dictionary.html)

set（无序、元素唯一）

# 创建空集合
set()			# 原因：{}用来创建一个空字典。   

添加元素到集合

  • add() 方法【添加单个元素】：
pythonmy_set = {1, 2, 3}  # 原始集合

# 使用 add() 方法添加单个元素
my_set.add(4)

# 输出: {1, 2, 3, 4}
print(my_set)
  • update() 方法【添加多个元素】：
pythonmy_set = {1, 2, 3}  # 原始集合

# 使用 update() 方法添加多个元素
my_set.update({3, 4, 5})

# 输出: {1, 2, 3, 4, 5}
print(my_set)

删除集合中的元素

  • 使用 remove() 方法【要删除的元素不存在，会引发 KeyError】：
pythonmy_set = {1, 2, 3, 4, 5}  # 原始集合

# 使用 remove() 方法删除指定元素
my_set.remove(3)

# 输出: {1, 2, 4, 5}
print(my_set)
  • 使用 discard() 方法【要删除的元素不存在，不会引发 KeyError】：
pythonmy_set = {1, 2, 3, 4, 5}  # 原始集合

# 使用 discard() 方法删除指定元素
my_set.discard(3)

# 输出: {1, 2, 4, 5}
print(my_set)

集合运算

  • 并集
pythonset1 = {1, 2, 3}
set2 = {3, 4, 5}

union_set = set1.union(set2)

# 输出: {1, 2, 3, 4, 5}
print(union_set)
  • 交集
pythonset1 = {1, 2, 3}
set2 = {3, 4, 5}

intersection_set = set1.intersection(set2)

# 输出: {3}
print(intersection_set)
  • 差集：返回包含在第一个集合中但不在第二个集合中的元素的新集合。
pythonset1 = {1, 2, 3}
set2 = {3, 4, 5}

difference_set = set1.difference(set2)

# 输出: {1, 2}
print(difference_set)
  • **对称差集：返回包含两个集合中所有不重复元素的新集合（即，去除两个集合的交集）。
pythonset1 = {1, 2, 3}
set2 = {3, 4, 5}

symmetric_difference_set = set1.symmetric_difference(set2)

# 输出: {1, 2, 4, 5}
print(symmetric_difference_set)
  • 使用运算符进行运算。
# | 表示并集
# & 表示交集
# - 表示差集
# ^ 表示对称差集
pythonset1 = {1, 2, 3}
set2 = {3, 4, 5}

union_set = set1 | set2  # 并集
intersection_set = set1 & set2  # 交集
difference_set = set1 - set2  # 差集
symmetric_difference_set = set1 ^ set2  # 对称差集

# 输出: {1, 2, 3, 4, 5}
print(union_set)

# 输出: {3}
print(intersection_set)

# 输出: {1, 2}
print(difference_set)

# 输出: {1, 2, 4, 5}
print(symmetric_difference_set)

更多set内置函数：

[Python3 集合 | 菜鸟教程 (runoob.com)](https://www.runoob.com/python3/python3-set.html)

Bytes类型（以b开头的字符串）

重点与str类型进行区分：

  • str类型（字符串）【Unicode编码存储】是以字符为单位进行处理的。
  • bytes类型【二进制数据的编码格式决定存储方式】是以字节为单位处理的。
b = b'' 		# 创建一个空的bytes
b = byte() 		# 创建一个空的bytes
b = b'hello' 	# 直接指定这个hello是bytes类型

b = bytes('string')						   #利用内置bytes方法，将字符串转换为默认utf-8的bytes
b = bytes('string',encoding='编码类型') 	#利用内置bytes方法，将字符串转换为指定编码的bytes

# 省事写法
byte1 = str.encode('编码类型') 					# 将str编码成bytes，默认为utf-8进行编码。
str1 = bytes.decode('编码类型')					# 将bytes解码成str，默认使用utf-8进行解码。

运算符

算术操作符

在混合计算时，Python会把整型转换成为浮点数。

+ 	# 加
- 	# 减
* 	# 乘
/	# 除			返回浮点数
%   # 取模（取整）

//	# 整除		返回整数		例子：9//2为4，-9//2为-5
**	# 幂		 				   例子：9**2为81

成员运算符

in		# 如果在指定的序列中找到值返回True,否则返回False

not in	# 如果在指定的序列中==没有找到==值返回Tue,否则返回False

身份运算符

运算符 描述 例子【例子中的id(X)函数用于获取对象内存地址】
is is是判断两个标识符是不是引用自一个对象 x is y,类似id(x)==id(y),如果引用的是同一个对象则返回Tue,否则返回False
is not is not是判断两个标识符是不是引用自不同对象 x is not y,类似id(a)!=id(b)。如果引用的不是同一个对象则返回结果True,否则返回False

比较运算符（类似C语言，不再赘述）

不再赘述

赋值运算符（类似C语言，不再赘述）

**=		# 幂赋值运算符		类似C语言
//=		# 取整除赋值运算符   类似C语言

位运算符（类似C语言，不再赘述）

&	# 按位与：各二进制位与：1&0为0，1&1为1，0&0为1
|	# 按位或：各二进制位或：（例：1001|0011为1011）

^	
# 按位异或：各二进制位异或(相异结果为1)：（例：1001^0011为1010）

~	# 按位取反：各二进制位取反：（例：~1为0）
<<	# 左移运算符：【高位丢弃，低位补0】各二进制位左移
>>	# 右移运算符：各二进制位左移

逻辑运算符（类似C语言，形式改动）

与  或  非
and or not

条件判断和循环语句

条件判断

if 判断条件1:
	第一个执行语句
elif 判断条件2:
	第二个执行语句
else:
	第三个执行语句

循环

for循环

  1. 遍历数字

  • 【i为从0到结束数的每一个数字】

    for i in range(结束数):	
    print(i)

  • 【i为从起始数到结束数的，以步进数为步进的每一个数字】

    for i in range(起始数,结束数,步进数):	# 左闭右开
	print(i)

  1. 遍历字符串【i为字符串中从前到后的每一个字符】

    for i in "asidojaodw":
    print(i)

  2. 遍历列表【i为列表中从前到后的每一个元素】

  • 正常遍历

    fruits = ['banana', 'apple',  'mango']
for i in fruit:
    print(i)

  • 通过数组下标遍历（其实就是列表）

    fruits = ['banana', 'apple',  'mango']
for index in range(len(fruits)):
   print ('当前水果 : %s' % fruits[index])

  • 通过枚举类型遍历

    fruits = ['banana', 'apple', 'mango']
for i, fruit in enumerate(fruits):
    print('下标：%d\t当前水果 : %s' % (i, fruit))

  1. 同时迭代多个对象

    # 以字典为例
my_dict = {'a': 1, 'b': 2, 'c': 3}
for key, value in my_dict.items():
    print(key, value)

  2. 循环判断

    for i in range(结束数):
    执行语句
else:
    不符合条件的执行语句

while循环

while 判断语句:
	执行语句
else:
    不符合条件的执行语句

break、continue、pass

  • break：跳出（终止）循环
  • continue：跳过本次循环
  • pass：占位符，空语句

函数

语法：

def 函数名称(形参):
	代码
	return 返回值	# 不带表达式的 return 相当于返回 None
函数名称(实参)

传入参数

  1. 位置参数

    这是最常见的参数传递方式，按照函数定义时参数的位置顺序传递实际参数。

def example_function(arg1, arg2):
    # 函数体

example_function(1, 'hello')
  1. 关键字参数
    在函数调用时，通过指定参数名来传递实际参数，不再依赖参数的位置。
example_function(arg2='world', arg1=2)
  1. 默认参数
    在函数定义时为参数指定默认值，在调用函数时如果没有提供对应参数的值，则使用默认值。
def example_function(arg1, arg2='default_value'):
    # 函数体

example_function(1)  # arg2 使用默认值 'default_value'
  1. 可变位置参数
    使用 * 来收集多余的位置参数，这些参数将以元组的形式传递给函数。
def example_function(arg1, *args):
    # 函数体

example_function(1, 'a', 'b', 'c')  # args 是一个包含 'a', 'b', 'c' 的元组
  1. 可变关键字参数
    使用 ** 来收集多余的关键字参数，这些参数将以字典的形式传递给函数。
def example_function(arg1, **kwargs):
    # 函数体

example_function(1, key1='value1', key2='value2')  # kwargs 是一个包含 {'key1': 'value1', 'key2': 'value2'} 的字典

注意：如果单独出现星号 *****，则星号 ***** 后的参数必须用关键字传入：

>>> def f(a,b,*,c):
...     return a+b+c
... 
>>> f(1,2,3)   # 报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() takes 2 positional arguments but 3 were given
>>> f(1,2,c=3) # 正常
6
>>>

lambda（匿名函数）

文件操作

file函数

open( )

语法
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
  • file: 必需，文件路径（相对或者绝对路径）。
  • mode: 可选，文件打开模式
  • buffering: 设置缓冲
  • encoding: 一般使用utf8
  • errors: 报错级别
  • newline: 区分换行符
  • closefd: 传入的file参数类型
  • opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。

mode参数

特性解析（可混用）

  • “+”：读写
  • “b”：二进制格式打开
模式 阐述
r【只读】 指针在开头（默认模式）。
w【写入】 文件存在 => 覆盖；
文件不存在 => 创建新文件。
a【追加】 指针在末尾。
文件存在 => 追加；
文件不存在 => 创建新文件。

举个栗子：

模式 阐述
rb【只读】 二进制格式，指针在开头。
wb【写入】 二进制格式。
ab【追加】 二进制格式，指针在结尾。
r+【读写】 指针在开头。
w+【读写】
a+【读写】 指针在结尾。
rb+【读写】 二进制格式，指针在开头。
wb+【读写】 二进制格式。
ab+【追加读写】 二进制格式，指针在末尾。

file.close( )

关闭文件。关闭后文件不能再进行读写操作。

file.read( )

读取指定的字符，开始时定位在文件头部，每执行一次向后移动指定字符数

file.readline( )

读取整行，包括 "\n" 字符

file.readlines( )

读取所有行并返回列表（若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区）。

其他file函数：

[Python3 File 方法 | 菜鸟教程 (runoob.com)](https://www.runoob.com/python3/python3-file-methods.html)

文件的相关操作【OS模块】

文件重命名

import os
os.rename("毕业论文.txt","毕业论文-最终版.txt")

删除文件

import os
os.rename("毕业论文.txt")

创建文件夹

import os
os.mkdir("张三")

获取当前目录

import os
os.getcwd()

改变默认目录

import os
os.chdir("../")

获取目录列表

import os
os.listdir("./")

删除文件夹

import os
os.rmdir("张三")

异常捕获

语法：

try_except_else_finally

抛出异常

使用rasie来抛出一个指定的异常

例子：
>>> try:
        raise NameError('HiThere')  # 模拟一个异常。
    except NameError:
        print('An exception flew by!')
        raise
   
An exception flew by!
Traceback (most recent call last):
  File "<stdin>", line 2, in ?
NameError: HiThere

抛出自定义异常

  • 继承自 Exception 类，直接继承或间接继承，
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

with语句：预定义的清理行为

  • 封装了 try…except…finally 编码范式，用于异常处理【更加易用】。
with open('./test_runoob.txt', 'w') as my_file:
    my_file.write('hello world!')

异常种类

名称 阐述
ArithmeticError 所有数值计算错误的基类
ImportError 导入失败
LookupError 无效数据查询的基类
NameError 未声明、初始化对象
OSError 操作系统错误
RuntimeError 一般的运行时错误
SyntaxError Python语法错误
ValueError 传入无效的参数
Warning 警告的基类
Exception 所有错误类型

推导式

语法：
结果一 if 判断条件 else 结果二 for 变量名 in 原列表

  • 列表(list)推导式

    # 例子：过滤掉长度小于或等于3的字符串列表，并将剩下的转换成大写字母：
names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
new_names = [name.upper()for name in names if len(name)>3]
# new_names为['ALICE', 'JERRY', 'WENDY', 'SMITH']

  • 字典(dict)推导式

    # 例子：提供三个数字，以三个数字为键，三个数字的平方为值来创建字典：
dic = {x: x**2 for x in (2, 4, 6)}
# dic为{2: 4, 4: 16, 6: 36}

  • 集合(set)推导式

    # 例子：判断不是 abc 的字母并输出：
a = {x for x in 'abracadabra' if x not in 'abc'}
# a为{'d', 'r'}

  • 元组(tuple)推导式【返回的是一个生成器对象。】

    # 例子：生成一个包含数字 1~9 的元组：
a = (x for x in range(1,10))
# a为(1, 2, 3, 4, 5, 6, 7, 8, 9)

笔记本

例子：利用列表翻转字符串

def reverseWords(input): 
      
    # 通过空格将字符串分隔符，把各个单词分隔为列表
    inputWords = input.split(" ") 
  
    # 翻转字符串
    # 假设列表 list = [1,2,3,4],  
    # list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样) 
    # inputWords[-1::-1] 有三个参数
    # 第一个参数 -1 表示最后一个元素
    # 第二个参数为空，表示移动到列表末尾
    # 第三个参数为步长，-1 表示逆向
    inputWords=inputWords[-1::-1] 
  
    # 重新组合字符串
    output = ' '.join(inputWords) 
      
    return output 
  
if __name__ == "__main__": 
    input = 'I like runoob'
    rw = reverseWords(input) 
    print(rw)

例子：集合找唯一字符

a = set('abracadabra')
b = set('alacazam')
print(a)

例子：格式打印

image-20240103033412417

products = [["iphone", 6888], ["MacPro", 14800], ["小米6", 2499], ["Coffee", 31], ["Book", 60], ["Nike", 699]]
print("-" * 5 + "商品列表" + "-" * 5)
i = 0
for product in products:
    print("%s\t%s\t%d" % (i, product[0], product[1]))
    i += 1

list1 = []
while True:
    i = input("想买什么?")
    if i != "q":
        list1.append(products[int(i)][0])
    else:
        for temp in list1:
            print(f"{temp}\t")
        break

例子：古诗写文件及粘贴

def write1():
    f = open("gushi.txt", "w")
    f.write("\
      击壤歌\n\
       佚名〔先秦〕\n\
    日出而作，日入而息。\n\
    凿井而饮，耕田而食。\n\
    帝力于我何有哉！")
    f.close()


def read_wirte():
    try:
        f2 = open("copy.txt", "w")
        f1 = open("gushi.txt", "r")
        try:
            f2.write(f1.read())
            print("复制完毕")
        finally:
            f1.close()
            f2.close()
    except Exception as result:
        print(result)


write1()
read_wirte()

细节

关于变量使用

变量是一个指向有类型的对象的指针，变量本身无任何类型。

point=5	# point是一个指针，而不是类型
point=10	# 这里是新生成一个int类型的对象point，再让指针point指向它，然后5被丢弃（point的值）

格式化字符（类似C语言，不再赘述）

转义字符（类似C语言，不再赘述）

  • \ 也可作为续行符
  • 前面加上r即可表示原始字符串
>>> print(r'Ru\noob')
Ru\noob

注意：向一个索引位置赋值，比如 word[0] = 'm' 会导致错误。

True与False

  • True：所有非零的数字和非空的字符串、列表、元组等
  • False：0、空字符串、空列表、空元组等

类型转换

显式类型转换

ord() 	# 取字符的ascii码值；
chr() 	# 取ascii码值对应的字符
hex()	# 取ascii码值对应的十六进制字符串
oct()	# 取ascii码值对应的八进制字符串

int()		# 转整数
float()		# 转浮点数
complex()	# 转复数
str()		# 转字符串
tuple()		# 转元组
list()		# 转列表
set()		# 转可变集合		frozenset()		# 转不可变集合
dict()		# 创建字典

repr()		# 转表达式字符串
eval()		# 计算在字符串中的有效Python表达式,并返回一个对象

隐式类型转换

自动将一种数据类型转换为另一种数据类型

# 例子：
# 较低数据类型（整数）就会转换为较高数据类型（浮点数）以避免数据丢失。
num_int = 123
num_flo = 1.23
num_new = num_int + num_flo

关于print的使用

# 打印单个变量
print("当前字母: " ,variable)
print("当前字母：%s"%variable)
# 打印多个变量：
print("当前字母: %s 第二个字母：%d" %(variable1,variable2))	# 以%s格式输出variable1和以%s格式输出variable2变量
# 打印字符串的结束符
print("你好",end="")	# 表示将字符串"你好"的结束值变为空，拓展：end="\n"  end="\t"  end="abc"

运算符优先级

运算符 描述
** 指数（最高优先级）
* / % // 乘 除 取模 取整除
+ - 加法减法
>> << 右移 左移
& 位'AND'
^ | 比较运算符
<= < > >= 等于运算符
< > == != 赋值运算符
is is not 身份运算符
in not in 成员运算符
and or not 逻辑运算符

枚举类型获取下标

mylist = ["a", "b", "c", "d"]
for i, x in enumerate(mylist):
    print(i + 1, x)

局部变量和全局变量【类似C语言，不再赘述】

局部变量变全局变量：加global

# 在函数中修改全局变量
a = 100

def test1():
    global a
    # 生命全同变量在通数中的标识有
    print("test1----修2改前：a=%d" % a)
    a = 200
    print("test1-----修2改后：a=%d" % a)

def test2():
    print("test2---a=%d" % a)  # 没有局局部变量，默认使用全局变量

test1()
test2()

异常捕获中的局部变量问题

import time

try:
    f = open("123.txt", "r")
    try:
        while True:
            content = f.readline()
            if len(content) == 0:
                break
            time.sleep(2)
            print(content)
    finally:
        f.close()
        print("文件关闭")
except Exception as result:
    print("发生异常。。。")