Python基础教程

一、Python编程基础

1、Python基础语法

Python标识符

Python标识符是变量、函数、类、模块或者其他Python对象的名称，有效的标识符应符合以下规则：

• 以字母A到Z、a到z或者下划线（_）开头

• 零个或多个字母、下划线和数字（0到9）

• 标识符中不能能包含@、$、%之类的字符

• Python语言区分大小写

• 不能以Python中的关键字作为标识符

此外，Python具有以下命名惯例：

• 类名以大写字母开头，所有其他标识符以小写字母开头

• 初始下划线用于私有标识符

• 两个初始下划线用于强私有标识符

行、缩进和多行

# Python在代码块中使用缩进而不是大括号。缩进在代码块中必须保持一致
if True:
    print("True")
else:
    print("False")

# 多行语句换行结尾时可以使用换行符或反斜杠（“\”）
total = x1 + \
        x2 + \
        x3

# 可以使用分号（“;”）分隔每条语句，从而在一行中定义多个语句（不推荐）
a = 10; b = 5; print(a); print(b)

Python中的引用和注释

# 井号 这是单行注释

'''
三个单引号
这是多行注释
'''

"""
三个双引号
这是多行注释（多行注释推荐使用该方式）
"""

# Python允许对字符串文字添加单引号（'）、双引号（"）、三引号（'''或"""），只要它们在字符串的开头和结尾可以相互匹配上
word = 'word'
line = "This is a sentence."
para = """This is a paragraph. This paragraph contains
more than one sentence."""

模块和包

hello.py：

def sayHello():
    print('Hello')

class helloWorld(object):
    def sayHelloWorld(self, name):
        print(name, 'sayHelloWorld')

main.py：

# 导入hello包
import hello
hello.sayHello()

# 导入hello包中所有类及方法
from hello import *
sayHello()
hw = helloWorld()
hw.sayHelloWorld('a')

# 导入hello包中指定的类
from hello import helloWorld
hw = helloWorld()
hw.sayHelloWorld('b')

2、Python中的简单数据类型

数字

# 将数字分配给两个变量并计算其乘积
>>> x = 4
>>> y = 6
>>> x * y
24

# 整数的计算操作
>>> 2 + 2
4
>>> 4 / 3
1.3333333333333333
>>> 3 * 8
24

# 将浮点数转换为指数形式
>>> fnum = 0.0000123456789000007
>>> "%.14e"%fnum
'1.23456789000007e-05'

# 使用int()函数和float()函数可将字符串转换为数字
word1 = "123"
word2 = "456.78"
var1 = int(word1)
var2 = float(word2)
print("var1:", var1, " var2:", var2)

# 也可使用eval()函数
var1 = eval(word1)
var2 = eval(word2)
print("var1:", var1, " var2:", var2)

# 将数字转换为其他底数
>>> x = 1234
>>> bin(x)
'0b10011010010'
>>> oct(x)
'0o2322'
>>> hex(x)
'0x4d2'

# 若要隐藏0b、0o、0x前缀，可以使用format()函数
>>> format(x, 'b')
'10011010010'
>>> format(x, 'o')
'2322'
>>> format(x, 'x')
'4d2'

# 负数用负号作为标识
>>> x = -1234
>>> format(x, 'b')
'-10011010010'
>>> format(x, 'x')
'-4d2'

# chr函数将一个正整数转换为对应的字符
>>> x = chr(65)
>>> x
'A'

# 注意：Python2使用ASCII字符串，而Python3使用UTF-8
# 打印一系列整数的字符
>>> for i in range(65, 91): print(chr(i), end = '')
...
ABCDEFGHIJKLMNOPQRSTUVWXYZ

# 使用ord获取字符所对应的数字
>>> for i in range(ord('a'), ord('z')): print(i, end = ' ')
...
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121

# round()函数可以将十进制值舍入到最接近的精度
>>> round(1.23, 1)
1.2
>>> round(-3.42, 1)
-3.4

# Python中格式化精度
>>> x = 1.23456
>>> format(x, '.2f')
'1.23'
>>> format(x, '.3f')
'1.235'
>>> 'value is {:.3f}'.format(x)
'value is 1.235'

# 计算浮点数时可能会出现精度问题，在对精度有较高要求时可以使用decimal模块
>>> a = 0.1
>>> b = 0.2
>>> a + b
0.30000000000000004
>>> (a + b) == 0.3
False

# 使用decimal模块（高精度计算模块）
>>> from decimal import Decimal
>>> a = Decimal('0.1')
>>> b = Decimal('0.2')
>>> a + b
Decimal('0.3')
>>> (a + b) == Decimal('0.3')
True

# 保留两位小数
>>> x = 1234.56789
>>> format(x, '0.2f')
'1234.57'

# 文本对齐，不满10个字符则使用空格在左侧填充至10个字符，保留一位小数
>>> format(x, '>10.1f')
'    1234.6'

# 文本对齐，不满10个字符则使用空格在右侧填充至10个字符
>>> format(x, '<10.1f')
'1234.6    '

# 文本对齐，不满10个字符则使用空格在两则填充至10个字符
>>> format(x, '^10.1f')
'  1234.6  '

# 千分符
>>> format(x, ',')
'1,234.56789'

# 千分符，保留一位小数
>>> format(x, '0,.1f')
'1,234.6'

# Python中使用分数
>>> from fractions import Fraction
>>> a = Fraction('1.25')
>>> b = Fraction(7, 16)
>>> print(a + b)
27/16

# 获取分子（numerator）和分母（denominator）
>>> print(a * b)
35/64
>>> c = a * b
>>> c.numerator
35
>>> c.denominator
64

# 分数转为float
>>> float(c)
0.546875

# limit_denominator方法用于将分母值限制为小于或等于给定对象的指定值的值。我们使用这种方法来查找浮点数的有理近似值
>>> print(c.limit_denominator(8))
4/7

# as_integer_ratio返回一对比率等于该浮点数的整型值，以元组tuple的形式。*指将结果拆分成一个个独立元素
>>> x = 3.75
>>> y = Fraction(*x.as_integer_ratio())
>>> y
Fraction(15, 4)

字符串

# 使用Unicode显示字符
chinese = u'\u570c\u63a3\u8a0e HTML5 \u53ca\u5176\u4ed6'
hiragana = u'D3 \u306F \u304B\u3063\u3053\u3043\u3043 \u3067\u3059!'

print('Chinese:', chinese)
print('Hiragana', hiragana)

''' 输出：
Chinese: 將探討 HTML5 及其他
Hiragana D3 は かっこぃぃ です!
'''

# 输出及字符串连接
>>> 'abc'
'abc'
>>> 'a' + 'b'
'ab'
>>> 'a' * 3
'aaa'
>>> x = 'a'; y = 'b' * 2
>>> print(x + y)
abb

# 字符串“解压缩”
>>> str = 'Hello'
>>> x1, x2, x3, x4, x5 = str
>>> print(x1, x2, x3, x4, x5)
H e l l o

# 从字符串中提取子字符串，str[start:stop:step]，str[开始位置:结束位置:步长]
>>> str = 'abcdef'
>>> str[0]
'a'
>>> str[-1]
'f'
>>> str[1:3]
'bc'
>>> str[0:2] + str[5:]
'abf'

# lower()和upper()方法可以将字符串分别转换为小写和大写
>>> str = 'Python'
>>> str.lower()
'python'
>>> str.upper()
'PYTHON'

# join()方法及字符串连接
>>> parts = ['Is', 'SF', 'In', 'California?']
>>> ' '.join(parts)
'Is SF In California?'
>>> ','.join(parts)
'Is,SF,In,California?'
>>> ''.join(parts)
'IsSFInCalifornia?'
>>> print(' '.join(['This', 'is', 'a', 'sentence']))
This is a sentence
>>> print('%s %s %s %s' % ('This', 'is', 'a', 'sentence'))
This is a sentence

# 字符串的比较
wordA = 'APPLE'
wordB = 'apple'
if wordA == wordB:
    print('两个单词拼写相同')
elif wordA.lower() == wordB.lower():
    print("两个单词意思相同")
else:
    print("两个单词不同")

''' 输出：
两个单词意思相同
'''

#  文本对齐，格式化字符串。ljust()和<为左对齐，rjust()和>为右对齐，center()和^为居中对齐
str1 = 'this is a string'
print(str1.ljust(40))
print(str1.rjust(40))
print(str1.center(40))
print('-' * 40)
print(format(str1, '<40'))
print(format(str1, '>40'))
print(format(str1, '^40'))

''' 输出：
this is a string                        
                        this is a string
            this is a string            
----------------------------------------
this is a string                        
                        this is a string
            this is a string   
'''

# 字符串的切片
text = 'this is a string'
print('前7个字符:', text[0:7])
print('第3-4个字符:', text[2:4])
print('最后一个字符:', text[-1])
print('倒数第3->倒数第2个字符:', text[-3:-1])

''' 输出：
前7个字符: this is
第3-4个字符: is
最后一个字符: g
倒数第3->倒数第2个字符: in
'''

# 数字和字母字符的检查
str1 = '4'
str2 = '4234'
str3 = 'b'
str4 = 'abc'
str5 = 'a1b2c3'

if str1.isdigit():
    print('this is a digital:', str1)
if str2.isdigit():
    print('this is a digital:', str2)
if str3.isalpha():
    print('this is a alphabetic:', str3)
if str4.isalpha():
    print('this is a alphabetic:', str4)
if not str5.isalpha():
    print('this is not pure alphabetic:', str5)
print('capitalized first letter:', str5.title())

''' 输出：
this is a digital: 4
this is a digital: 4234
this is a alphabetic: b
this is a alphabetic: abc
this is not pure alphabetic: a1b2c3
capitalized first letter: A1B2C3
'''

# 搜索和替换字符串
item1 = 'abc'
item2 = 'Abc'
text = 'This is a text string with abc'
print(text.find(item1), item1 in text)
print(text.find(item2), item2 in text)
print(text.replace(item1, item2))
''' 输出：
27 True
-1 False
This is a text string with Abc
'''

# 删除和替换字符
text = '    leading and trailing with space    '
print('text1:', 'x', text, 'y')
print('text2:', 'x', text.lstrip(), 'y')
print('text3:', 'x', text.rstrip(), 'y')
print('text4:', 'x', text.strip(), 'y')

import re
text  = 'a    b'
print(text.replace(' ', ''))
print(re.sub('\s+', ' ', text))

''' 输出：
text1: x     leading and trailing with space     y
text2: x leading and trailing with space     y
text3: x     leading and trailing with space y
text4: x leading and trailing with space y
ab
a b
'''

3、Python中的简单交互

文件读写

文件读写模式：

test.txt：

This is first line
This is second line


This is file tail

main.py：

# 读取所有文件内容
f = open('test.txt')
s = f.read()
print(s)
f.close()

''' 输出：
This is first line
This is second line


This is file tail
'''

# 读取文件所有行，并形成相应的列表
f = open('test.txt')
sList = f.readlines()
print(sList)
f.close()

''' 输出：
['This is first line\n', 'This is second line\n', '\n', '\n', 'This is file tail']
'''

# 读取一行
f = open('test.txt')
s = f.readline()
print(s)
f.close()

''' 输出：
This is first line
'''

# 文件覆盖写入
f = open('test.txt', mode='w')
f.write('add new line')
f.close()

f = open('test.txt', mode='r')
print(f.read())
f.close()

''' 输出：
add new line
'''

# seek()移动文件指针，tell()返回当前指针位置，
f = open('test.txt', mode='r')
f.seek(5)
print(f.tell())
print(f.read())
f.close()

''' 输出：
5
ew line
'''

日期处理

# 日期输出
import time
import datetime

print("Time in seconds since the epoch: %s" % time.time())
print("Current date and time: ", datetime.datetime.now())
print("Or like this: ", datetime.datetime.now().strftime("%y-%m-%d %H:%M"))
print("Current year: ", datetime.datetime.today().strftime("%Y"))
print("Month of year: ", datetime.datetime.today().strftime("%B"))
print("Week number of the year: ", datetime.datetime.today().strftime("%W"))
print("Weekday of the week: ", datetime.datetime.today().strftime("%w"))
print("Month of year: ", datetime.datetime.today().strftime("%j"))
print("Month of the month: ", datetime.datetime.today().strftime("%d"))
print("Month of week: ", datetime.datetime.today().strftime("%A"))

''' 输出：
Time in seconds since the epoch: 1686700879.2473118
Current date and time:  2023-06-14 08:01:19.247311
Or like this:  23-06-14 08:01
Current year:  2023
Month of year:  June
Week number of the year:  24
Weekday of the week:  3
Month of year:  165
Month of the month:  14
Month of week:  Wednesday
'''

# 字符串转换为日期
from datetime import datetime

text = '2020-01-01'
y = datetime.strptime(text, '%Y-%m-%d')
z = datetime.now()
diff = z - y
print('Date diffrence:', diff)

''' 输出：
Date diffrence: 1260 days, 8:10:55.594845
'''

# 日期计算
>>> from datetime import timedelta
>>> a = timedelta(days=2, hours=6)
>>> b = timedelta(hours=4.5)
>>> c = a + b
>>> c.days
2
>>> c.seconds
37800
>>> c.seconds / 3600
10.5
>>> c.total_seconds() / 3600
58.5

异常处理

# 不同类型相加会产生异常
x = 4
y = 'abc'
z = x + y

''' 输出：
Traceback (most recent call last):
  File "main.py", line 3, in <module>
    z = x + y
TypeError: unsupported operand type(s) for +: 'int' and 'str'
'''

# 可以使用try-except捕获异常
try:
    x = 4
    y = 'abc'
    z = x + y
except:
    print('cannot add incompatible types:', x, y)

''' 输出：
cannot add incompatible types: 4 abc
'''

# 读取指定文件，并捕获异常。使用raise手动抛出异常
import sys
try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
# 也可使用except (IOError, ValueError, TypeError)捕获多个异常
except IOError as err:
    print('I/O error: {0}'.format(err))
except ValueError:
    print('Could not convert data to an integer.')
except:
    print('Unexpected errr:', sys.exc_info()[0])
    raise

''' 若文件不存在，则输出：
I/O error: [Errno 2] No such file or directory: 'myfile.txt'
'''

用户输入

# 可以使用input()函数来读取用户输入
sum = 0
msg = 'Enter a number: '
while True:
    num = input(msg)
    if num == 'end':
        break
    try:
        sum += eval(num)
    except:
        print(num, 'is not a number')
print('sum = ', sum)

''' 输出：
Enter a number: 1
Enter a number: 3
Enter a number: x
x is not a number
Enter a number: end
sum =  4
'''

命令行参数

• sys.argv显示命令行参数列表

• len(sys.argv)显示命令行参数的数量

#!/user/bin/python
import sys
print('Number of arguments:', len(sys.argv), 'arguments')
print('Argument List:', str(sys.argv))

> python .\main.py arg1 arg2 arg3
Number of arguments: 4 arguments
Argument List: ['.\\main.py', 'arg1', 'arg2', 'arg3']

二、条件逻辑、循环和函数

1、Python中的条件逻辑

if-elif-else

x = 25
if x < 18:
    print("under 25")
elif 18 <= x <= 35:
    print("between 18 and 35")
else:
    print("over 35")

''' 输出：
between 18 and 35
'''

break/continue/pass语句

# break提前跳出循环
print('first loop')
for x in range(1, 4):
    if x == 2:
        break
    print(x)

# continue跳过本次循环
print('second loop')
for x in range(1, 4):
    if x == 2:
        continue
    print(x)

# pass表示什么都不做，提供了占位符
print('third loop')
for x in range(1, 4):
    if x == 2:
        pass
    print(x)

保留关键字

• 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

#使用关键字作为变量会抛出异常
return = 'empty'
print(return)

''' 输出：
SyntaxError: invalid syntax
'''

2、Python中的运算符

运算符优先级

in/not in/is/isnot 比较运算符

# 使用in和not in判断一个值是否出现在序列中
list = [1, 2, 3, 4]
print(1 in list)
print(5 not in list)

''' 输出：
True
True
'''

# is和is not用来判断两个对象是否是同一个对象
ch = 'A'
ch2 = 'A'
ch3 = 'B'
print(ch is ch2)
print(ch is not ch3)

''' 输出：
True
True
'''

# 运算符也可以级联使用
a = 3; b = 5; c = 5
print(a < b == c)

''' 输出：
True
'''

and/or/not 布尔运算符

# and和运算、or或运算、not非运算
print(True and False)
print(True or False)
print(not True)

''' 输出：
False
True
False
'''

3、Python中的变量和参数

局部变量和全局变量

# 显式声明全局变量
global z
z = 3


def changeVar(z):
    z = 4 # 局部变量，修改不会改变全局变量值
    print('z in function:', z)


print('first global z:', z)

if __name__ == '__main__':
    changeVar(z)
    print('second global z:', z)

''' 输出：
first global z: 3
z in function: 4
second global z: 3
'''

值传递和引用传递

# i和li为形参
def changeVal(i, li):
    i = 1  # 值传递修改不会影响实参值
    li.append(['a', 'b', 'c'])  # 引用传递会影响实参值


num = 0
mylist = [1, 2, 3, 4]
changeVal(num, mylist)  # num和mylist为实参
print('num = ', num)  # num为值传递
print('mylist = ', mylist)  # mylist为引用传递

''' 输出：
num =  0
mylist =  [1, 2, 3, 4, ['a', 'b', 'c']]
'''

4、Python中的循环

for循环

# 简单for循环
for i in range(0, 10):
    print(i, end=',')

''' 输出：
0 1 2 3 4 5 6 7 8 9 
'''

# 列表遍历
list = [1, 3, 6, 9, 11]
for i in list:  # 正序遍历列表
    print(i, end=' ')
print()
for i in reversed(list):  # 逆序遍历列表
    print(i, end=' ')

''' 输出：
1 3 6 9 11 
11 9 6 3 1 
'''

# 使用for循环计算n次方
def pwr(num, n):
    sum = 1
    for i in range(n):
        sum *= num
    return sum

num = 3
for i in range(1, 5):
    print(num, '的', i, '次方: ', pwr(num, i))  # print(num ** i)，使用**运算符也可以计算n次方

''' 输出：
3 的 1 次方:  3
3 的 2 次方:  9
3 的 3 次方:  27
3 的 4 次方:  81
'''

# 嵌套循环打印九九乘法表
for i in range(1, 10):
    for j in range(1, i + 1):
        print('{}×{}={}'.format(j, i, i * j), end='\t')
    print()

''' 输出：
1×1=1	
1×2=2	2×2=4	
1×3=3	2×3=6	3×3=9	
1×4=4	2×4=8	3×4=12	4×4=16	
1×5=5	2×5=10	3×5=15	4×5=20	5×5=25	
1×6=6	2×6=12	3×6=18	4×6=24	5×6=30	6×6=36	
1×7=7	2×7=14	3×7=21	4×7=28	5×7=35	6×7=42	7×7=49	
1×8=8	2×8=16	3×8=24	4×8=32	5×8=40	6×8=48	7×8=56	8×8=64	
1×9=9	2×9=18	3×9=27	4×9=36	5×9=45	6×9=54	7×9=63	8×9=72	9×9=81	
'''

# 使用split()分割字符串
text = 'This is a string contains abc and Abc'
word = 'abc'

for w in text.split(' '):
    if w == word:
        print("contains")
        break
print(word in text)

''' 输出：
contains
True
'''

# 文本按指定格式输出，打印指定宽度
text = 'This is a string contains abc and Abc'

i = 0
for w in text.split(' '):
    if i % 2 == 0:
        print('%10s' % w, end='')  # 左补充，右对齐
    if i % 2 != 0:
        print('%10s' % w)
    i += 1
print('-' * 21)
for w in text.split(' '):
    if i % 2 == 0:
        print('%-10s' % w, end='')  # 右补充，左对齐
    if i % 2 != 0:
        print('%-10s' % w)
    i += 1

''' 输出：
      This        is
         a    string
  contains       abc
       and       Abc
--------------------
This      is        
a         string    
contains  abc       
and       Abc       
'''

# 使用join()也可去除多余空格，来连接字符串
text = ' This  is   a    string    contains   abc  and Abc '

print(text)
print(' '.join(text.split()))
print('--'.join(text.split()))

''' 输出：
 This  is   a    string    contains   abc  and Abc 
This is a string contains abc and Abc
This--is--a--string--contains--abc--and--Abc
'''

while循环

# 简单while循环
i = 1
while i < 5:
    print(i, end=' ')
    i += 1

''' 输出：
1 2 3 4 
'''

# while循环列表
list = [1, 2, 3, 4]
while list:
    print(list, end=',')
    print(' pop', list.pop())

''' 输出：
[1, 2, 3, 4], pop 4
[1, 2, 3], pop 3
[1, 2], pop 2
[1], pop 1
'''

5、自定义函数

自定义函数规则

• 函数代码块以关键字def开头，后面跟随函数名和括号

• 任何输入参数都应放到括号内

• 函数体的第一行语句时可选的语句——函数的文档字符串，或者docstring

• 每个函数的代码块都已冒号（:）开头，并且缩进

• 语句 return [expression] 退出一个函数，并可选地返回一个表达式给调用者。不带参数的return语句等同于返回None

• 如果一个函数没有指定返回语句，那么这个函数自动返回None，这是Python中的一种特殊类型的值

# 简单函数定义和调用
def func():
    print('This is a function')
func()

# 函数设定中的默认值
def numberFunc(a, b=10):
    print(a, b)
def stringFunc(a, b='xyz'):
    print(a, b)
def collectionFunc(a, b=None):
    if b is None:
        print('No value assigned to b')
        return
    print(a, b)

numberFunc(1)
stringFunc('acb')
collectionFunc([1, 2, 3], [4, 5, 6])

''' 输出：
1 10
acb xyz
[1, 2, 3] [4, 5, 6]
'''

# 返回多个参数
def multipleValues():
    return '1', '2', '3'

x, y, z = multipleValues()
print(x, y, z)

''' 输出：
1 2 3
'''

# 可变参数
def sum(*list):
    sum = 0
    for i in list:
        sum += i
    return sum

print(sum(1, 3, 5, 9))

''' 输出：
18
'''

# 多个可变参数
def func(a, b, *args, **kwargs):
    print('a = ', a)
    print('b = ', b)
    print('args = ', args)
    print('kwargs = ', kwargs)

func(1, 3, 5, 7, 9, name='rainio', sex='male')

''' 输出：
a =  1
b =  3
args =  (5, 7, 9)
kwargs =  {'name': 'rainio', 'sex': 'male'}
'''

lambda表达式

add = lambda x, y: x + y
print(add(2, 4))
print(add('abc', 'xyz'))

递归

# 简单递归
def fun(i):
    if i <= 0:
        return
    print(i)
    fun(i - 1)

fun(3)

''' 输出：
3
2
1
'''

# 递归打印九九乘法表
def multTable(i, j, max):
    if max > 9:
        return
    if j > max:
        print()
        multTable(i + 1, 1, max + 1)
        return
    print('{}×{}={}'.format(j, i, i * j), end='\t')
    multTable(i, j + 1, max)

multTable(1, 1, 1)

''' 输出：
1×1=1	
1×2=2	2×2=4	
1×3=3	2×3=6	3×3=9	
1×4=4	2×4=8	3×4=12	4×4=16	
1×5=5	2×5=10	3×5=15	4×5=20	5×5=25	
1×6=6	2×6=12	3×6=18	4×6=24	5×6=30	6×6=36	
1×7=7	2×7=14	3×7=21	4×7=28	5×7=35	6×7=42	7×7=49	
1×8=8	2×8=16	3×8=24	4×8=32	5×8=40	6×8=48	7×8=56	8×8=64	
1×9=9	2×9=18	3×9=27	4×9=36	5×9=45	6×9=54	7×9=63	8×9=72	9×9=81	
'''

三、Python数据类型

1、列表

# 列表的简单操作
>>> list = [1, 2, 3, 4, 5]
>>> list
[1, 2, 3, 4, 5]
>>> list[2]
3
>>> list2 = list + [6, 7, 8, 9, 10]
>>> list2
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list2.append(11)
>>> list2
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
>>> len(list)
5
>>> x = ['a', 'b', 'c']
>>> y = [1, 2, 3]
>>> z = [x, y]
>>> z
[['a', 'b', 'c'], [1, 2, 3]]
>>> z[0]
['a', 'b', 'c']
>>> len(z)
2

# 多个变量分配给一个列表
>>> point = [7, 'z', ('a', 'b')]
>>> x, y, (a, b) = point
>>> x
7
>>> y
'z'
>>> a
'a'
>>> b
'b'
# 参数不匹配会抛出异常
>>> x, y = point
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)

# 翻转和排序列表
>>> a = [4, 1, 2, 3]
>>> a.reverse()
>>> a
[3, 2, 1, 4]
>>> a.sort()
>>> a
[1, 2, 3, 4]
>>> a[::-1]
[4, 3, 2, 1]
>>> min(a)
1
>>> max(a)
4

# 第二种排序方式
>>> a = [1, 2, 3, 4]
>>> a.sort(reverse=True)
>>> a
[4, 3, 2, 1]

# 第三种排序方式，不修改a的值
>>> a = [1, 2, 3, 4]
>>> sorted(a, reverse=True)
[4, 3, 2, 1]
>>> a
[1, 2, 3, 4]

# 根据ASCII对字母进行排序
>>> list1 = ['a', 'A', 'b', 'B', 'Z']
>>> sorted(list1)
['A', 'B', 'Z', 'a', 'b']
>>> sorted(list1, reverse=True)
['b', 'a', 'Z', 'B', 'A']
>>> sorted(list1, key=str.lower)
['a', 'A', 'b', 'B', 'Z']

# 根据字符串长度排序
>>> list1 = ['a', 'AA', 'bbb', 'BBBB', 'ZZZZZZZ']
>>> sorted(list1, key=len, reverse=True)
['ZZZZZZZ', 'BBBB', 'bbb', 'AA', 'a']

# 过滤列表，列表表达式
list1 = ['a', 'list', 'of', 'words']
list2 = [s.upper() for s in list1]
list3 = [s for s in list1 if len(s) <= 2]
list4 = [s for s in list1 if 'w' in s]

print(list1)
print(list2)
print(list3)
print(list4)

''' 输出：
['a', 'list', 'of', 'words']
['A', 'LIST', 'OF', 'WORDS']
['a', 'of']
['words']
'''

# 计算字符串中的数字和字母数量
str1 = 'abc4234AFde'
digitCount = 0
alphaCount = 0
upperCount = 0
lowerCount = 0

for w in str1:
    if w.isdigit():
        digitCount += 1
        alphaCount += 1
    elif w.isalpha():
        alphaCount += 1
        if w.upper() == w:
            upperCount += 1
        else:
            lowerCount += 1

print('Original String: ', str1)
print('Number of digital', digitCount)
print('Total alphanumberic', alphaCount)
print('Upper Case Count', upperCount)
print('Lower Case Count', lowerCount)

''' 输出：
Original String:  abc4234AFde
Number of digital 4
Total alphanumberic 11
Upper Case Count 2
Lower Case Count 5
'''

# append()函数和split()函数
list = [10, 'a', ['b', 'c']]
list.append('e')
print(list)
list[2].append('d')
print(list)
x1, x2, x3, x4 = list
print(x3)
print('-' * 32)
list = 'This is a sentence'.split()
print(list)
x1, x2, x3, x4 = list
print(x3)

''' 输出：
[10, 'a', ['b', 'c'], 'e']
[10, 'a', ['b', 'c', 'd'], 'e']
['b', 'c', 'd']
-------------------------------
['This', 'is', 'a', 'sentence']
a
'''

# 遍历成对的列表
list1 = [1, 2, 3]
list2 = [4, 5, 6, 7]

print([[x, x ** 2] for x in list1])  # 创建一个新列表
print([[a, b] for a in list1 for b in list2])  # 两个列表中每个元素的排列组合
print([list1[i] + list2[i] for i in range(min(len(list1), len(list2)))])  # 计算两个列表前三个元素对应相乘

''' 输出：
[[1, 1], [2, 4], [3, 9]]
[[1, 4], [1, 5], [1, 6], [1, 7], [2, 4], [2, 5], [2, 6], [2, 7], [3, 4], [3, 5], [3, 6], [3, 7]]
[5, 7, 9]
'''

# 列表相关函数的使用
a = [1, 2, 3, 2, 4, 2, 5]
print('count:', a.count(1), a.count(2))  # count()函数统计指定字符出现的次数
a.insert(3, -8)  # insert()函数在指定位置插入元素
print('insert:', a)
a.remove(2)  # remove()函数移除从左到右第一个匹配的字符
print('remove:', a)
a.append(9)  # append()函数添加一个元素
print('append:', a)
print('index:', a.index(2))  # index()函数获取从左到右第一个匹配到的元素下标（从0开始）
a.reverse()  # reverse()函数反转列表
print('reverse:', a)
a.sort()  # sort()函数对列表进行排序
print('sort:', a)
a.extend([8, 9, 2])  # extend()函数使用指定列表进行扩展
print('extend:', a)
a.pop(2)  # pop()函数弹出从左到右第一个匹配到的元素
print('pop:', a)
a.pop()  # pop()函数默认弹出最后一个元素
print('pop:', a)

''' 输出：
count: 1 3
insert: [1, 2, 3, -8, 2, 4, 2, 5]
remove: [1, 3, -8, 2, 4, 2, 5]
append: [1, 3, -8, 2, 4, 2, 5, 9]
index: 3
reverse: [9, 5, 2, 4, 2, -8, 3, 1]
sort: [-8, 1, 2, 2, 3, 4, 5, 9]
extend: [-8, 1, 2, 2, 3, 4, 5, 9, 8, 9, 2]
pop: [-8, 1, 2, 3, 4, 5, 9, 8, 9, 2]
pop: [-8, 1, 2, 3, 4, 5, 9, 8, 9]
'''

2、元组（不可变列表）

# 元组的创建
tuple = (1)
print(tuple)
tuple = (1, )  # 只有一个元素的元组应使用此方式创建
print(tuple)
tuple = (1, 2, 3)
print(tuple)
tuple[0] = 4  # 元组修改会产生异常

''' 输出：
1
(1,)
(1, 2, 3)
Traceback (most recent call last):
  File "main.py", line 7, in <module>
    tuple[0] = 4
TypeError: 'tuple' object does not support item assignment
'''

3、集合

>>> list = ['a', 'b', 'c', 'd', 'c', 'a']
>>> set1 = set(list)
>>> set1
{'d', 'b', 'c', 'a'}
>>> 'a' in set1
True
>>> 's' in set1
False
>>> set2 = set(['a', 'e', 'f'])
# 并集
>>> set1 | set2
{'e', 'b', 'c', 'f', 'd', 'a'}
# 集合相减
>>> set2 - set1
{'e', 'f'}
>>> set1 - set2
{'d', 'b', 'c'}
# 交集
>>> set1 & set2
{'a'}
# 异或
>>> set1 ^ set2
{'b', 'c', 'd', 'e', 'f'}

4、字典

# 创建一个字典
>>> map = {'x': 1, 'y': 2}
# 根据key获取value
>>> map['x']
1
>>> map.get('x')
1
# 使用[]获取value时不存在会抛出异常，使用get()方法则不会
>>> map['z']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'z'
>>> map.get('z')
# 生成新的字典
>>> {x: x ** 2 for x in [1, 2, 3]}
{1: 1, 2: 4, 3: 9}
# 检查字典key是否存在
>>> 'x' in map
True
>>> 'z' in map
False

# map的简单操作
>>> map = {}
# 添加元素
>>> map['x'] = '1'
>>> map['y'] = '2'
>>> map['z'] = '3'
>>> map
{'x': '1', 'y': '2', 'z': '3'}
# 删除元素
>>> del map['x']
>>> map
{'y': '2', 'z': '3'}
# 分别遍历key和value
>>> map.keys()
dict_keys(['y', 'z'])
>>> map.values()
dict_values(['2', '3'])
# 同时遍历key和value
>>> for key, value in map.items(): print(key, value)
...
y 2
z 3
# 给key设置新的value
>>> map['y'] = 4
>>> map
{'y': 4, 'z': '3'}
# 字典拷贝
>>> map1 = map.copy()
>>> del map1['y']
>>> map
{'y': 4, 'z': '3'}
>>> map1
{'z': '3'}
# 字典元素个数
>>> len(map)
2
# 使用字符串打印字典
>>> str(map)
"{'y': 4, 'z': '3'}"
# 清空字典
>>> map.clear()
>>> map
{}

# 有序字典
from collections import OrderedDict

d = OrderedDict([('first', 1), ('second', 2), ('third', 3)])
print(d.items())
print(d['first'], d.get('second'))
del d['first']
d['first', 1] = 1
print(d)

''' 输出：
odict_items([('first', 1), ('second', 2), ('third', 3)])
1 2
OrderedDict([('second', 2), ('third', 3), (('first', 1), 1)])
'''

# 一键多值字典
from collections import defaultdict

d = {'a': [1, 2, 3], 'b': [4, 5]}
print('d1 = ', d)

d = defaultdict(list)
d['a'].append(1)
d['a'].append(2)
d['a'].append(1)
print('d2 = ', d)

d = defaultdict(set)
d['a'].add(1)
d['a'].add(2)
d['a'].add(1)
print('d3 = ', d)

''' 输出：
d1 =  {'a': [1, 2, 3], 'b': [4, 5]}
d2 =  defaultdict(<class 'list'>, {'a': [1, 2, 1]})
d3 =  defaultdict(<class 'set'>, {'a': {1, 2}})
'''

5、其他数据类型

# 使用enumerate()函数同时检索位置索引和相应的值
>>> for index, value in enumerate(['x', 'y', 'z']): print(index, value)
...
0 x
1 y
2 z
# 不能修改字符串，只能重新赋值
>>> s = 'string'
>>> s[0] = a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

# 使用type()函数判断变量类型
>>> i1 = 123
>>> i2 = 1.23
>>> s = 'string'
>>> l = [1, 2]
>>> t = (1, 2)
>>> type(i1)
<class 'int'>
>>> type(i2)
<class 'float'>
>>> type(s)
<class 'str'>
>>> type(l)
<class 'list'>
>>> type(t)
<class 'tuple'>

四、迭代器、生成器与装饰器

1、迭代器

from collections.abc import Iterable, Iterator

# 同时具有__iter__()和__next__()方法的是可迭代对象，也是迭代器
class bothIterAndNext:
    def __iter__(self):
        pass

    def __next__(self):
        pass
print(isinstance(bothIterAndNext(), Iterable))
print(isinstance(bothIterAndNext(), Iterator))

# 只有__iter__()方法的是可迭代对象，不是迭代器
class onlyIter:
    def __iter__(self):
        pass
print(isinstance(onlyIter(), Iterable))
print(isinstance(onlyIter(), Iterator))

# 只有__next__()方法的既不是可迭代对象，也不是迭代器
class onlyNext:
    def __next__(self):
        pass
print(isinstance(onlyNext(), Iterable))
print(isinstance(onlyNext(), Iterator))

''' 输出：
True
True
True
False
False
False
'''

# 使用next()访问迭代器中的元素
import sys  # 引入 sys 模块

list = [1, 2, 3, 4]
it = iter(list)  # 创建迭代器对象

while True:
    try:
        print(next(it), end=' ')
    except StopIteration:
        sys.exit()

''' 输出：
1 2 3 4 
'''

2、生成器

# 生成器只在调用时执行过程，不会一次性生成所有数据
ge = [x ** 2 for x in range(1, 10000)]  # 普通列表
ge = (x ** 2 for x in range(1, 10000))  # 生成器
print(ge)
print(next(ge))  # 使用next()操作生成器
print(next(ge))

# yield用来暂存方法过程
def odd():
    i = 1
    while True:
        yield i
        i += 2

o = odd()
print(next(o))
print(next(o))
print(next(o))

''' 输出：
1
3
5
'''

3、装饰器

# 装饰器会在实际函数前执行
def decorator(fun):
    def wrapper(*args, **kw):
        print("This is decorator")
        return fun(*args, **kw)
    return wrapper

@decorator  # 使用@调用装饰器
def func():
    print("This is func")

func()

''' 输出：
This is decorator
This is func
'''

# 装饰器获取原函数的参数
def decorator(fun):  # fun即为原函数
    def wrapper(*args, **kwargs):  # 此处为了接受可变参数，wrapper可修改为其他名称，但不建议修改
        print(fun.__name__)
        print("This is decorator, i get a number : ", args[0])
        return fun(*args, **kwargs)
    return wrapper

@decorator
def func(num):
    print("This is func, i get a number : ", num)

func(10)
print(func.__name__)  # 函数名被修改为wrapper

''' 输出：
func
This is decorator, i get a number :  10
This is func, i get a number :  10
wrapper
'''

# 装饰器参数
def decorator(size):  # 用来获取装饰器参数
    def actual_decorator(fun):  # 实际的装饰器
        def wrapper(*args, **kwargs):
            print("This is decorator, i get a number : ", args[0])
            return fun(*args, **kwargs)
        return wrapper
    print('size = ', size)
    return actual_decorator

@decorator(size=1)
def func(num):
    print("This is func, i get a number : ", num)

func(10)

''' 输出：
size =  1
This is decorator, i get a number :  10
This is func, i get a number :  10
'''