Python使用的一些示例

字符串(str，字符串是不可变的序列)

name = "xxx"
age = "20"
print("我是", name, ", 我今年", age, "岁了, ", "明年我", int(age)+1, "岁!", sep="")

# %格式化(传统的格式化方式)
print('我是%s, 我今年%s岁了, 明年我%d岁!' % (name, age, int(age)+1))
# format格式化(Python2.6引入)
print('我是{}, 我今年{}岁了, 明年我{}岁!'.format(name, age, int(age)+1))
print('我是{v1}, 我今年{v2}岁了, 明年我{v3}岁!'.format(v1=name, v2=age, v3=int(age)+1))
print('我是{0}, 我今年{1}岁了, 明年我{2}岁!'.format(name, age, int(age)+1))
# f-string格式化(Python3.6引入)
print(f'我是{name}, 我今年{age}岁了, 明年我{int(age)+1}岁!')

full_name = f"{'zhang'} {'shuaifeng'}"
message = f"Come on, {full_name.title()}!   "
# strip删除message中感叹号后面的空格。这里需要注意字符串是不可变的数据类型，对其strip操作时会并
# 不是在原字符串基础上进行原地操作，而是在其副本上进行操作。所以下面将对副本的操作结果关联到原来
# 的变量message，既需要再将新值关联到原来的变量。
message = message.strip()
print(message)

#chr(i) 内置函数返回 Unicode 码位为整数 i 的字符，它是 ord() 的逆函数
#ord(c)内置函数返回单字符对应的 Unicode 码位，它是 chr() 的逆函数
print(chr(97))
print(ord('a'))

.....................................................................................................................

列表(list，列表是可变的序列)

1）sort和reverse示例

# 使用对象方法sort对列表进行永久排序，修改后再也无法恢复到原来的排列顺序(对列表进行了原地操作)
# 使用全局的内置函数sorted对列表进行临时排序(新建了列表的副本，对列表的副本进行的操作。新建操作
def func(string):
    return int(string[:-3])

FileName = ["10.py", "2.py", "8.py", "6.py", "100.py"]
FileName.sort(key=func)
print(FileName)

lst = ['4', '3', '1000', '7', '19']
# 内置函数reversed(seq)对给定序列返回一个反向迭代器(迭代器一定是可迭代对象，因此可以将其转
# 换为列表等， 常用的返回迭代器的reversed/zip/enumerate/filter/map等。另外需要注意的是迭
#代器只能从头到尾迭代一次，因此下面第二次打印为空列表)
ret = reversed(lst)
#内置函数list([iterable])将一个iterable对象转化为列表并返回，如果没有传入参数返回空的列表
print(list(ret))    # ['19', '7', '1000', '3', '4']
print(list(ret))    # []

2）列表推导式

        由一对方括号里面包含一个表达式，后面跟一个 for 子句，然后是零个或多个 for 或 if 子句

组成，其结果将是一个新列表，由表达式依据后面的 for 和 if 子句的内容进行求值计算而得

出

#示例一(嵌套)：
matrix = [[1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12]]

result = [[row[i] for row in matrix] for i in range(4)]
#其等价于如下语句
result = []
for i in range(4):
    result.append([row[i] for row in matrix])

result = []
for i in range(4):
    temp = []
    for row in matrix:
        temp.append(row[i])
    result.append(temp)

#示例二：
FileName = ["10.py", "2.py", "8.py", "6.py", "100.py"]
num_lst = [int(i[:-3]) for i in FileName]
num_lst.sort()
res = [str(j)+".py" for j in num_lst]
print(res)

.....................................................................................................................

字典(dictionary，可变的)       

1）dict.fromkeys(iterable[, value])

# fromkeys创建一个新字典，以 iterable 的元素作为键，value 作为值，value 默认为 None
dic1 = dict.fromkeys(("name", "age", "gender"))
print(dic1)
dic2 = dict.fromkeys(("name", "age", "gender"), "I don't know!")
print(dic2)

2）可使用get()方法来访问值

        使用放在方括号内的键从字典中获取感兴趣的值的方法，有的时候可能会引法问题：如果指定的键不存在，就会报错。就字典而言，为避免出现这样的错误，可使用get()方法在指定的键不存在时返回一个默认值(如果指定第二个参数，返回None)。

alien_0 = {'color':'green', 'speed':'slow'}
#print(alien_0['point']) # 报错
point_value = alien_0.get('point', 'No point found')
print(point_value)  # No point found

3）遍历字典

        以下的，items()返回由字典键组成的一个新视图, values()返回由字典值组成的一个新视图，keys()返回由字典键组成的一个新视图；返回的对象是视图对象，这意味着当字典改变时，视图也会相应改变。这里需要注意，新视图与原数据是有关联的(指向原数据，原数据改变后，新视图随着实时改变)；另外新视图也是可迭代对象(因此也可以转为列表等，转为列表后就和原数据没关系了)。

favorite_languages = {
    'a':'C',
    'b':'C++',
    'c':'C',
    'd':'Rust'
}
#遍历键值对
for key, value in favorite_languages.items():
    print(f"key:{key}, vaule:{value}")
#遍历键，keys方法返回的是一个列表
for key in favorite_languages.keys():
    print(f'key:{key}')
#按特定的顺序遍历字典中的所有键
for key in sorted(favorite_languages.keys()):
    print(f'sorted key:{key}')
#遍历值
for value in favorite_languages.values():
    print(f'value:{value}')
#使用集合set剔除字典值的重复项(集合中的每个元素都是独一无二的)
for value in set(favorite_languages.values()):
    print(f'value by set:{value}')

4）字典推导式

#示例一：
dic = {k: v for k, v in zip((1, 2, 3), (4, 5, 6))}
print(dic)

#示例二：
FileName = ["10.py", "2.py", "8.py", "6.py", "100.py"]
dic = {int(i[:-3]): i for i in FileName}
key_lst = sorted(dic)
print([dic[j] for j in key_lst])    # 字典对象的索引是魔术方法__getitem__实现的

.....................................................................................................................

集合(set是可变的。但是frozenset是不可变的) 

1）frozenset

        是不可变的类型，因此其对象方法一般是新建操作(在副本上进行操作)。 

# frozenset([iterable])函数返回一个新的 frozenset 对象，即不可变的集合，其元素来自于
# iterable，如果未指定参数，则返回冻结的空集合(set 中的元素必须是不可变类型的，而 frozenset
# 是可以作为 set元素的)
print(frozenset()) # frozenset()
print(frozenset("1234")) # frozenset({'4', '3', '1','2'})
print(frozenset([1, 2, 3, 4])) # frozenset({1, 2, 3, 4})
print(frozenset({"one":1, "two":2, "three":3})) # frozenset({'two', 'three', 'one'})

set1 = {"four"}
set1.add(frozenset({'two', 'three', 'one'}))
print(set1) # {frozenset({'one', 'two', 'three'}), 'four'}

tup = (3, 5, 2, 1, 5, 5)
new_set = frozenset(tup)
print(new_set)  # frozenset({1, 2, 3, 5})
new_tup = tuple(new_set)
print(new_tup)  # (1, 2, 3, 5)

2）set的一些运算

# 把一个列表变成集合，就会自动去掉重复的元素
li = [1, 2, 4, 5, 7, 7, 4, 5]
a = set(li)
print(a)
# 测试多组集合数据之间的交集、差集、并集等关系
a = set("abdefga")
b = set("abc")
c = set("aef")
print(c <= a) # 判断c是否是a的子集
print(a - b) # 返回a和b的差集
print(a | b) # 返回a和b的并集
print(a & b) # 返回a和b的交集
print(a ^ b) # 返回

3）集合推导式

set1 = {x**2 for x in range(4)}
print(set1)

set1 = {x for x in 'abracadabra' if x not in 'abc'}
print(set1)

.....................................................................................................................

封包和解包

1）封包

        将多个值赋值给一个变量时，Python 会自动将这些值封装成元组，这个特性称之为封包。

2）解包

        可迭代对象都支持解包 。

1) 序列赋值过程中的解包:
# 可以在其中一个变量前面加一个星号(*)，代表这个变量可接收0个/1个/多个元素，并把它们组成
# 列表来赋值，理解起来类似于不定长参数中的*args。解包过程：先把其他变量根据位置确定对应
# 要赋值的元素，剩下的元素都归带星号(*)的变量，组成列表来赋值。
a, b, *c, d = (1, 2, 3, 4, 5)
print(a, b, c, d) # 1 2 [3, 4] 5
a, b, *c, d, e = (1, 2, 3, 4)
print(a, b, c, d, e) # 1 2 [] 3 4
# 不允许多个带星号(*)的变量，因为会有歧义
a, *b, *c, d = (1, 2, 3, 4, 5)
print(a, b, c, d)
# 这种解包的写法是错误的
*a = (1, 2, 3, 4, 5)
# 正确的写法应该是这样
*a, = (1, 2, 3, 4, 5)
print(a) # [1, 2, 3, 4, 5]
# 通常约定：当变量不需要使用时, 可以用下划线命名
*a, _, _ = (1, 2, 3, 4, 5)
print(a) # [1, 2, 3]

2) 在可迭代对象前面加一个星号（*）,此时若可迭代对象为字典的话，解包只有键参与;在字典对象
前面加双星（**），这种解包方式主要运用在函数传参的过程中。
a = (1, 2, 3, 4, 5)
print(*a) # 1 2 3 4 5
print(*(1, 2, 3, 4, 5)) # 同上
# 在可迭代对象前面加一个星号（*），使其以位置参数的形式传入函数
def func(a, b, c, d=None):
    print(a, b, c, d)
tup = (1, 2, 3, 4)
dic = {'name': "Tom", 'age': 18, 'height': 188}
func(*tup) # 等效于 func(1, 2, 3, 4)
func(*dic) # 等效于 func('name', 'age', 'height')
# 在字典对象前面加双星（**），使其以关键字参数的形式传入函数
def func(a, b, c, d=None):
    print(a, b, c, d)
dic = {'a': "Tom", 'b': 18, 'c': 188, 'd': True}
func(**dic) # 等效于 func(a="Tom", b=18, c=188, d=True)
dict(**dic) # 等效于 dict(a="Tom", b=18, c=188, d=True)

.....................................................................................................................

三元表达式：

score = 77
result = print("优") if score >= 90 else print("良") if score >= 80 else \
    print("及格") if score >= 60 else print("差")
print(result)

.....................................................................................................................

函数的特殊形参： /和*

# 默认情况下，函数的参数传递形式可以是位置参数或是显式的关键字参数
# 也可以用 / 和 * 来限制参数的传递形式
# 其中 / 为仅限位置参数，限制在它之前的形参必须以位置参数的形式 传入，而不能用关键字参数
# 其中 * 为仅限关键字参数，限制在它之后的形参必须以关键字参数的 形式传入
# 这两个特殊参数只是为了限制参数的传递形式，不需要为它们传入实参
def func(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):
    pass
func(1, 2, 3, kwd1=4, kwd2=5)

.....................................................................................................................

类型标注

# a. Python 对标注类型并不强制，不按照标注类型也不会报错。
# b. 类型标注主要被用于第三方工具，比如类型检查器、集成开发环境、 静态检查器等
# c. 标注以字典的形式存放在函数的 __annotations__ 属性中，不会影响函 数的任何其他部分
# d. 自从 Python3.5 以来，发布了 typing 包，为类型标注提供了支持

def func(a: int, b: str, c: list, d: tuple, e: dict, f: set) -> tuple:
    return a, b, c, d, e, f
print(func(1, 2, 3, 4, 5, 6))
print(func(1, "2", [3], (4, ), {5: 5}, {6}))
print(func.__annotations__)


from typing import List, Tuple, Dict, Set, Union, Callable, Iterable, Iterator, Generator
# List[int]：建议参数为列表，且所有元素为int类型
# Tuple[int, str]：建议参数为元组，且第一个元素为int类型，第二个元素为str类型
# Dict[str, int]：建议参数为字典，且所有键为str类型，值为int类型
# Set[str]：建议参数为集合，且所有元素为str类型
def func(a: int, b: str, c: List[int], d: Tuple[int, str], e: Dict[str, int], f: Set[str]) -> Tuple:
    return a, b, c, d, e, f
print(func(1, 2, 3, 4, 5, 6))
print(func(1, "2", [3, 4, 5], (4, "5"), {"5": 4}, {"6"}))


# 嵌套
def func(a: Dict[str, List[Tuple[int, int, int]]]):
    pass
# 建议多种类型(这里的UNION表示选择其中之一)
def func(a: Union[str, list, set]):
    pass
func({})
func([1])
func("1")
func({1})

# Callable[[int], int] 建议参数为函数，且只有一个为int类型的参数，返回int类型
def my_sort(a: list, f: Callable[[int], int], c: bool):
    return sorted(a, key=f, reverse=c)
print(my_sort([1, -3, 2], abs, True))

.....................................................................................................................

命名空间和作用域

1）三种命名空间

       内置命名空间( 由builtins模块实现)，在解释器启动的时候会准备好这个命名空间，然后持续到解释器停止，所以不用import就可以直接适用其中的内置函数/类名称等。它是为所有的.py文件服务的。

        在模块被读入时会创建一个全局命名空间，它是为当前.py文件服务的。全局命名空间也是持续到解释器退出。

#通过以下命令可以返回全局的命名空间(返回的是一个字典，由此可见全局命名空间记录的东西是字
#典实现的)。
print(globals())

        局部命名空间包含函数中定义的名称，记录了函数的变量、参数等 一个函数的局部命名空间在这个函数被调用时创建，持续到函数结束。

#通过在定义的函数中执行如下命令会返回当前局部命名空间(也是由字典来记录)，需要注意的是若将
#该命令放到全局区域的话输出结果与print(globals())相同。
print(locals())

        命名空间的查找顺序为：局部命名空间 -> 全局命名空间 -> 内置命名空间。所以在局部命名空间print一个未定义的变量，就会区全局命名空间找......

2）四种作用域

#在当前作用域如果找不到对应名称，则去更大一级作用域去找，直到最后找不到就会报错.作用域依次
#增大的顺序为局部作用域（Local）、闭包函数外的函数中（Enclosing，也是一种局部作用域）、全
#局作用域（Global）、內建作用域（Built-in）。

#一般来说，如果一个函数结束，函数内部的变量、参数会被释放掉；而闭包则不同，它在外部函数结束
#时，会把内部函数中用到的外部函数的变量、参数保存到内部函数的__closure__属性中，以提供给内部
#函数使用。
def outer():
    a = c + 2 # Enclosing可以调用全局变量c
    def inner():
        b = c + 3 # 局部作用域可以调用全局变量c
        print(a + b) # 局部作用域可以调用Enclosing变量a
    inner()

c = 1 # 全局变量
print(c) # 调用全局变量c

# abs是内置函数、int是内置类，它们都在内建作用域builtins模块中
num1 = abs(-100)
num2 = int(3.141592653)

.....................................................................................................................

一些常用函数

zip(*iterables)函数示例

# a. 返回一个元组的迭代器(迭代器一定是可迭代对象，只不过只能打印一次)，其中的第 i 个元组
# 包含来自每个可迭代对象的第 i 个元素
# b. 当所输入可迭代对象中最短的一个被耗尽时，迭代器将停止迭代
# c. 不带参数时，它将返回一个空迭代器
# d. 当只有一个可迭代对象参数时，它将返回一个单元组的迭代器
result1 = zip("abcd", "efgh")
print(list(result1))
result2 = zip("abcd", "efg")
print(list(result2))
result3 = zip()
print(list(result3))
result4 = zip("abcd")
print(list(result4))

help函数示例

        比如，help(sorted)

filter(function, iterable)示例

#a. function：函数（function 必需能够接受1个实参），也可以为 None。
#b. iterable：可迭代对象。
#c. 将 iterable 中每个元素作为参数传递给函数，根据函数的返回结果进行判断 True 或 False，将
#判断为 True 的 iterable 中的元素构建新的迭代器并返回。
#d. 如果 function 为 None，直接判断 iterable 中元素 True 或 False，再返回为 True 的元素
#构建的新的迭代器
object1 = filter(lambda x: x-1, [1, 2, 3, False, 4])
print(list(object1))
object3 = filter(None, [1, 2, 0, 3, False, 4])
print(list(object3))

map(func, *iterables)示例

#a. func：函数（func 必需能够接收 iterables 个数的实参）
#b. iterables：可迭代对象
#c. 用 iterables 中的每个元素作为函数的参数来调用函数，以迭代器形式返回所有结果
#d. 当有多个 iterables 对象时，最短的 iterables 耗尽则函数停止
# 当有多个 iterables 对象时，最短的 iterables 耗尽则函数停止
result = list(map(lambda x, y, z: x+y+z, [1, 2, 3], [3, 2, 1], [1, 3]))
print(result)    # [5, 7]

reduce(function, iterable[, initial]) 示例

# a. function：函数（function 必需能够接收两个实参）
# b. iterable：可迭代对象
# c. initial：初始值
# d. 在没有指定 initial 参数时，先把 iterable 的前两个元素作为参数调用函数，把这次函数的
# 结果以及iterable 的下一个元素又作为参数再调用函数，以此类推
# e. 在指定 initial 参数时，先把 initial 值和 iterable 的第一个元素作为参数调用函数，把
# 这次函数的结果以及 iterable 的下一个元素又作为参数再调用函数，以此类推
# f. 如果 iterable 为空，返回 initial ，此时如果没有指定 initial，则报错
# g. 如果 iterable 只有一个元素且没有指定 initial，返回该元素

from functools import reduce
# 过程：10*2 + 2*123 = 266
result = reduce(lambda x, y: 10*x + 2*y, [123], 2)
print(result)

eval和exec函数示例

        都可以将字符串当成python程序来执行，它们的区别是eval函数只能执行单个表达式，并返回执行的结果；而exec(函数还可以执行代码块，无返回值（return None）。

# eval(expression[, globals[, locals]]) 
# exec(object[, globals[, locals]])

string = "4345789"
lst = [int(i) for i in string]
print(sum(lst)) # 40

print(eval('+'.join(string)))   # 40
exec('print('+'+'.join(string)+')') # 40


# 需要注意的是eval和exec后面二个可选参数用来指定全局命名空间和局部命名空间(字典的形式)。如果
# 不指定locals，则globals和locals是相同的，如下所示二条语句相同：
print(eval("a+b", {'a':4, 'b':5}))
print(eval("a+b", {'a':4, 'b':5}, {'a':4, 'b':5}))

 dir函数示例

        用来收集模块中定义的名称，

import builtins
# 可以用来收集内置命名空间中builtin中定义的名称。不带参数时，返回当前.py文件中定义好的一些名称。
print(dir(builtins))

 .....................................................................................................................

PyCharm的一些快捷键

ctrl + p  显示函数的参数信息
ctrl + ?  批量注释/批量去掉注释，另外还可以在选中要注释的内容后按单引号或者双引号来多行注释
home 把光标移动到行的开头
end 把光标移动到行的结尾
ctrl + r  替换
shift + enter 在当前行下方新建一行
ctrl + alt + enter 在当前行上方新建一行