Python学习笔记（十三）format()数字格式化 和 内置函数(25-52)

【摘要】 史上最为详细的python学习笔记,记录学习过程的知识点和难点

format()数字格式化

下表展示了 str.format() 格式化数字的多种方法：

>>>print(“{:.2f}”.format(3.1415926))

3.14

^,<,>分别是居中、左对齐、右对齐，后面带宽度，

:号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。

+表示在正数前显示+，负数前显示–；

（空格）表示在正数前加空格

b、d、o、x分别是二进制、十进制、八进制、十六进制。

此外我们可以使用大括号{}来转义大括号，如下实例：

实例

#!/usr/bin/python

# -*- coding: UTF-8 -*-

print(“{} 对应的位置是 {{0}}“.format(“runoob“))

输出结果为：

runoob 对应的位置是{0}

# 25、frozenset()：
”’
描述：
返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
语法：
frozenset([iterable])
参数：
iterable–可迭代的对象，比如列表、字典、元组等等。
返回值：
返回新的frozenset对象，如果不提供任何参数，默认会生成空集合
”’
print(frozenset())
# frozenset()
a = frozenset(range(10)) # 生成一个新的不可变集合
print(a)
# frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
b = frozenset(‘runoob’) # 创建不可变集合
print(b)
# frozenset({‘r’, ‘o’, ‘u’, ‘n’, ‘b’})
”’
为什么需要冻结的集合（即不可变的集合）呢？
因为在集合的关系中，有的集合中的元素是另一个集合的情况，但是普通集合（set）本身是可变的，
那么它的实例就不能存放在另一个集合中（set中的元素必须是不可变类型）。
所以，frozenset提供了不可变的集合的功能，当集合不可变时，
它就满足了作为集合中的元素的要求，就可以放在另一个集合中了。
”’


# 26、getattr()：
”’
描述：
用于返回一个对象属性值
语法：
getattr(object, name[, default])
参数：
object–对象
name–字符串，对象属性
default–默认返回值，如果不提供该参数，在没有对应属性时，将触发AttributeError
返回值：
返回对象属性值
”’
class A(object):
bar = 11

a = A()
print(getattr(a, ‘bar’)) # 获取类属性bar的值
# print(getattr(a, ‘bar2’)) # 属性bar2不存在，触发异常AttributeError: ‘A’ object has no attribute ‘bar2’
print(getattr(a, ‘bar2’, –1)) # 属性bar2不存在，但设置了默认值-1，返回值为-1

class A():
def set(self, a, b):
x = a
a = b
b = x
print(a, b)

a = A()
c = getattr(a, ‘set’)
c(a=‘1’, b=‘2’) # 打印结果：2 1
##### 看不懂#####


# 27、globals()：
”’
描述：
以字典类型返回当前位置的全部全局变量。对比locals()函数
语法：
globals()
参数：
无
返回值：
以字典类型返回当前位置的全部全局变量
”’
print(globals()) # globals函数返回一个全局变量的字典，包括所有导入的变量
# {‘__name__’: ‘__main__’, ‘__doc__’: ‘\n’, ‘__package__’: None, ‘__loader__’: <_frozen_importlib_external.SourceFileLoader object at 0x000001D272980910>, ‘__spec__’: None, ‘__annotations__’: {}, ‘__builtins__’: <module ‘builtins’ (built-in)>, ‘__file__’: ‘D:/Project/Pycharm/Project1/review1.py’, ‘__cached__’: None, ‘A’: <class ‘__main__.A’>, ‘Coordinate’: <class ‘__main__.Coordinate’>, ‘point1’: <__main__.Coordinate object at 0x000001D2745EB2E0>, ‘a’: <__main__.A object at 0x000001D2745EBE50>, ‘b’: frozenset({‘u’, ‘o’, ‘b’, ‘n’, ‘r’}), ‘c’: <bound method A.set of <__main__.A object at 0x000001D2745EBE50>>, ‘zipped’: <zip object at 0x000001D274601E80>, ‘a1’: (1, 2, 3), ‘a2’: (4, 5, 6), ‘b1’: (1, 2, 3), ‘b2’: (4, 5, 6), ‘seasons’: [‘Spring’, ‘Summer’, ‘Autumn’, ‘Winter’], ‘i’: 4, ‘seq’: [‘one’, ‘two’, ‘three’, ‘four’], ‘element’: ‘four’, ‘x’: 10, ‘n’: 81, ‘expr’: ‘\nz = 30\nsum = x + y + z\nprint(sum)\n’, ‘func’: <function func at 0x000001D2729661F0>, ‘list1’: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], ‘is_odd’: <function is_odd at 0x000001D2745EA670>, ‘tmplist’: <filter object at 0x000001D2745EBC70>, ‘newlist’: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100], ‘math’: <module ‘math’ (built-in)>, ‘is_sqr’: <function is_sqr at 0x000001D2745EA700>, ‘site’: {‘name’: ‘‘, ‘url’: ‘www.com’}, ‘my_list’: [‘‘, ‘www..com’], ‘AssignValue’: <class ‘__main__.AssignValue’>, ‘my_value’: <__main__.AssignValue object at 0x000001D2745EBC40>}


# 28、hasattr()：
”’
描述：
用于判断对象是否包含对应的属性
语法：
hasattr(object, name)
参数：
object–对象
name–字符串，属性名
返回值：
如果对象有该属性返回True，否则返回False
”’
class Coordinate:
x = 10
y = –5
z = 0

point1 = Coordinate()
print(hasattr(point1, ‘x’)) # True
print(hasattr(point1, ‘y’)) # True
print(hasattr(point1, ‘z’)) # True
print(hasattr(point1, ‘no’)) # False，没有该属性


# 29、hash()：
”’
描述：
用于获取一个对象（字符串或数值等）的哈希值
语法：
hash(object)
参数：
object–对象
返回值：
返回对象的哈希值
”’
print(hash(‘test’)) # 字符串，结果3138493826556676253
print(hash(123456789)) # 数字，结果123456789
print(hash(str([1, 2, 3]))) # 集合，结果3084751386921177152
print(hash(str(sorted({‘a’: 1})))) # 字典，结果-2240541016805128389


# 30、help()：
”’
描述：
用于查看函数或模块用途的详细说明
语法：
help([object])
参数：
object–对象
返回值：
返回对象帮助信息
”’
help(‘sys’) # 查看sys模块的帮助
# ……显示帮助信息……
help(‘str’) # 查看str模块的帮助
# ……显示帮助信息……
a = [1, 2, 3] # 查看列表list帮助信息
help(a)
# ……显示帮助信息……
help(a.append) # 显示list的append方法的帮助
# ……显示帮助信息……

# 31、hex()：
”’
描述：
用于将一个指定数字转换为16进制数
语法：
hex(x)
参数：
x–一个整数
返回值：
返回一个字符串，以0x开头
”’
print(hex(255)) # 0xff
print(hex(–42)) # -0x2a
print(hex(12)) # 0xc
print(type(hex(12))) # <class ‘str’>


# 32、id()：
”’
描述：
id()函数返回对象的唯一标识符，标识符是一个整数。
CPython中id()函数用于获取对象的内存地址。
语法：
id([object])
参数：
object–对象
返回值：
返回对象的内存地址
”’
a = ‘runoob’
print(id(a)) # 2604293190192
b = 1
print(id(b)) # 140719388104352


# 33、input()：
”’
描述：
Python3.x中input()函数接收一个标准输入数据，返回string类型。

注意：在Python3.x中raw_input()和input()进行了整合，去除了raw_input()，仅保留了
input()函数，其接收任意性输入，将所有输入默认为字符串处理，并返回字符串类型。
语法：
input([prompt])
参数：
prompt–提示信息
返回值：

”’
### input()需要输入python表达式
a = input(‘input: ‘) # 输入整数：123
print(type(a)) # 字符串类型：<class ‘str’>
b = input(‘input: ‘) # 输入字符串表达式：runoob
print(type(b)) # 字符串类型：<class ‘str’>

### input()接收多个值
# 输入三角形的三边长
a, b, c = (input(‘请输入三角形三边的长：‘).split())
a = int(a)
b = int(b)
c = int(c)
# 计算三角形的半周长p
p = (a + b + c) / 2
# 计算三角形的面积s
s = (p * (p – a) * (p – b) * (p – c)) ** 0.5
# 输出三角形的面积
result_list = [a, b, c, p, s]
print(”’三角形的三边长为：{:.2f}，{:.2f}，{:.2f}
三角形的半周长p为：{:.2f}
三角形的面积s为：{:.2f}”’.format(*result_list))


# 34、int()：
”’
描述：
用于将一个字符串或数字转换为整型
语法：
int(x, base=10)
参数：
x–字符串或数字
base–进字数，默认为十进制
返回值：
返回整型数据
”’
print(int()) # 不传入参数时，得到结果0
print(int(3)) # 3
print(int(3.6)) # 3
print(int(’12’, 16)) # 18，如果是带参数base的话，12要以字符串形式输入，12为16进制
print(int(‘0xa’, 16)) # 10
print(int(’10’, 8)) # 8
print(int(‘1001’, 2)) # 1001才是2进制格式，转换为十进制数字9
print(int(‘123’, 8)) # 视123为8进制数，对应的10进制为83


# 35、isinstance()：
”’
描述：
判断一个对象是否是一个已知的类型，类似type()。

instance()和type()的却别：
instance()会认为子类是一种父类类型，考虑继承关系。
type()不会认为子类是一种父类类型，不考虑继承关系。

如果要判断两个类型是否相同，推荐使用isinstance()。
语法：
isinstance(object, classinfo)
参数：
object–实例对象
classinfo–可以是直接或间接类名、基本类型或者由它们组成的元组。

对于基本类型来说，classinfo可以是–int, float, bool, complex, str(字符串), list, dict(字典), set, tuple
要注意的是，classinfo的字符串是str而不是string，字典也是简写dict
返回值：
如果对象的类型与参数二的类型（classinfo）相同则返回True，否则返回False。
”’
a = 2
print(isinstance(a, int)) # True
print(isinstance(a, str)) # False
print(isinstance(a, (str, int, list))) # 是元组中的一个，返回True
print(‘—————‘)
# type()与isinstance()区别：
class A:
pass

class B(A):
pass

print(isinstance(A(), A)) # True
print(type(A()) == A) # True
print(isinstance(B(), A)) # True，考虑继承关系
print(type(B()) == A) # False，不考虑继承关系


# 36、issubclass()：
”’
描述：
用于判断参数class是否是类型参数classinfo的子类
语法：
issubclass(class, classinfo)
参数：
class–类
classinfo–类
返回值：
如果class是classinfo的子类则返回True，否则返回False
”’
class A:
pass

class B(A):
pass

print(issubclass(B, A)) # True


# 37、iter()：
”’
描述：
用来生成迭代器
语法：
iter(object[, sentinel]) sentinel标记，哨兵，守卫，放哨
参数：
object–支持迭代的集合对象
sentinel–如果传递了第二个参数，则参数object必须是一个可调用的对象（如函数），此时，
iter创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用object。
返回值：
迭代器对象
”’
lst = [1, 2, 3]
for i in iter(lst):
print(i)


# 38、len()：
”’
描述：
返回对象(字符、列表、元组等)长度或项目个数

len()是内置函数，返回对象的长度（元素个数）。
实参可以是序列（如string、bytes、tuple、list或range等）
也可以是集合（如dictionary、set或frozenset等）。
len()不是字符串类的方法。
语法：
len(s)
参数：
s–对象
返回值：
返回对象长度
”’
str = ‘runoob’
print(len(str)) # 字符串长度6
lst = [1, 2, 3, 4, 5]
print(len(lst)) # 列表元素个数5


# 39、list()：
”’
描述：
用于将元组或字符串转换为列表。
注意：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是()，列表是[]
语法：
list(seq)
参数：
seq–要转换为列表的元组或字符串
返回值：
返回列表
”’
tuple1 = (123, ‘Google’, ‘Runoob’, ‘Taobao’)
print(‘元组元素：‘, tuple1)
# 元组元素：(123, ‘Google’, ‘Runoob’, ‘Taobao’)
list1 = list(tuple1)
print(‘列表元素：‘, list1)
# 列表元素：[123, ‘Google’, ‘Runoob’, ‘Taobao’]

str = ‘hello world’
print(‘字符串：‘, str)
# 字符串：hello world
list2 = list(str)
print(‘列表元素：‘, list2)
# 列表元素：[‘h’, ‘e’, ‘l’, ‘l’, ‘o’, ‘ ‘, ‘w’, ‘o’, ‘r’, ‘l’, ‘d’]


# 40、locals()：
”’
描述：
locals()函数会以字典类型返回当前位置的全部局部变量。对比globals()函数
对于函数，方法，lambda表达式，类，以及实现了__call__方法的类实例，它都返回True。
语法：
locals()
参数：
无
返回值：
返回字典类型的局部变量
”’
print(locals())
# {‘__name__’: ‘__main__’, ‘__doc__’: ‘\n’, ‘__package__’: None, ‘__loader__’: <_frozen_importlib_external.SourceFileLoader object at 0x000001E9BAAAF910>, ‘__spec__’: None, ‘__annotations__’: {}, ‘__builtins__’: <module ‘builtins’ (built-in)>, ‘__file__’: ‘D:/Project/Pycharm/Project1/review1.py’, ‘__cached__’: None}
print(globals())
# {‘__name__’: ‘__main__’, ‘__doc__’: ‘\n’, ‘__package__’: None, ‘__loader__’: <_frozen_importlib_external.SourceFileLoader object at 0x000001E9BAAAF910>, ‘__spec__’: None, ‘__annotations__’: {}, ‘__builtins__’: <module ‘builtins’ (built-in)>, ‘__file__’: ‘D:/Project/Pycharm/Project1/review1.py’, ‘__cached__’: None}

def runoob(arg): # 两个局部变量：arg、z
z = 1
print(locals())
# {‘arg’: 4, ‘z’: 1}
print(globals())
# {‘__name__’: ‘__main__’, ‘__doc__’: ‘\n’, ‘__package__’: None, ‘__loader__’: <_frozen_importlib_external.SourceFileLoader object at 0x000002758D87F910>, ‘__spec__’: None, ‘__annotations__’: {}, ‘__builtins__’: <module ‘builtins’ (built-in)>, ‘__file__’: ‘D:/Project/Pycharm/Project1/review1.py’, ‘__cached__’: None, ‘runoob’: <function runoob at 0x000002758D8661F0>}

runoob(4)


# 41、map()：
”’
描述：
map()函数会根据提供的函数对指定序列做映射。
第一个参数function以参数序列中的每一个元素调用function函数，返回包含每次
function函数返回值的新列表
语法：
map(function, iterable, …)
参数：
function–函数
iterable–一个或多个序列
返回值：
返回一个迭代器
”’
def square(x): # 计算平方数
return x ** 2

print(map(square, [1, 2, 3, 4, 5])) # 计算列表中各个元素的平方
# <map object at 0x000001DE5EFFB6D0> # 返回迭代器
print(list(map(square, [1, 2, 3, 4, 5]))) # 使用list()转换为列表
# [1, 4, 9, 16, 25]
print(list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))) # 使用lambda匿名函数
# [1, 4, 9, 16, 25]


# 42、max()：
”’
描述：
返回给定参数的最大值，参数可以为序列
语法：
max(x, y, z, …)
参数：
x–数值表达式
y–数值表达式
z–数值表达式
返回值：
返回给定参数的最大值
”’
print(‘max(80, 100, 1000):’,max(80, 100, 1000))
print(‘max(-20, 100, 400):’,max(–20, 100, 400))
print(‘max(-80, -20, -10):’,max(–80, –20, –10))
print(‘max(0, -100, -400):’,max(0, –100, –400))


# 43、min()：
”’
描述：
返回给定参数的最小值，参数可以为序列
语法：
min(x, y, z, …)
参数：
x–数值表达式
y–数值表达式
z–数值表达式
返回值：
返回给定参数的最小值
”’
print(‘max(80, 100, 1000):’,max(80, 100, 1000))
print(‘max(-20, 100, 400):’,max(–20, 100, 400))
print(‘max(-80, -20, -10):’,max(–80, –20, –10))
print(‘max(0, -100, -400):’,max(0, –100, –400))


# 44、memoryview()：
”’
描述：
返回给定参数的内存查看对象（memory view）。
所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，
在不需要复制对象的基础上允许Python代码访问。
语法：
memoryview(obj)
参数：
obj–对象
返回值：
返回元组列表
”’
### Python2.x应用：
v = memoryview(‘abcdef’)
print(v[1]) # b
print(v[–1]) # f
print(v[1:4]) # <memory at 0x00000000033399D8>
print(v[1:4].tobytes()) # bcd
print(v[1:4].tolist()) # [98, 99, 100]

### Python3.x应用：
v = memoryview(bytearray(‘abcdef’, ‘utf-8’))
print(v[1]) # 98
print(v[–1]) # 102
print(v[1:4]) # <memory at 0x000001E231C69340>
print(v[1:4].tobytes()) # b’bcd’
print(v[1:4].tolist()) # [98, 99, 100]


# 45、next()：
”’
描述：
next()返回迭代器的下一个项目
next()函数要和生成迭代器的iter()函数一起使用。
语法：
next(iterable[, default])
参数：
iterable–可迭代对象
default–可选，用于设置在没有下一个元素时的默认返回值，
如果不设置且又没有下一个元素，则会触发StopIteration异常。
返回值：
返回迭代器的下一个项目
”’
# 首先获得Iterator对象：
ite = iter([1, 2, 3, 4, 5])
# 循环：
while True:
try:
# 获得下一个值：
x = next(ite)
print(x)
except StopIteration:
# 遇到StopIteration就退出循环
print(‘没有可返回的元素！‘)
break
”’打印结果
1
2
3
4
5
没有可返回的元素！”’
# y = next(ite) # 报出异常：StopIteration


# 46、object()：
”’
描述：
创建一个空对象
不能向这个对象添加新的属性或方法。
这个对象是所有类的基础，它拥有所有类默认的内置属性和方法。
语法：
object()
参数：
无参数
返回值：
返回一个空对象
”’
# help(object()) # 查看object()函数的帮助
x = object()
print(x)
# <object object at 0x0000027DED394FE0>
print(dir(x)) # 查看对象x的属性、方法列表
# [‘__class__’, ‘__delattr__’, ‘__dir__’, ‘__doc__’, ‘__eq__’, ‘__format__’, ‘__ge__’, ‘__getattribute__’, ‘__gt__’, ‘__hash__’, ‘__init__’, ‘__init_subclass__’, ‘__le__’, ‘__lt__’, ‘__ne__’, ‘__new__’, ‘__reduce__’, ‘__reduce_ex__’, ‘__repr__’, ‘__setattr__’, ‘__sizeof__’, ‘__str__’, ‘__subclasshook__’]


# 47、oct()：
”’
描述：
将一个整数转换成8进制字符串，8进制以0o作为前缀表示
语法：
oct(x)
参数：
x–整数
返回值：
返回8进制字符串
”’
print(oct(10)) # 0o12
print(oct(20)) # 0o24
print(oct(15)) # 0o17


# 48、open()：
”’
描述：
Python open()函数用于打开一个文件，并返回文件对象。
在对文件进行处理过程中都需要使用到这个函数，
如果该文件无法被打开，则会抛出OSError异常。

注意：
使用open()函数一定要保证关闭文件对象，即调用close()函数。
open()函数常用形式是接收两个参数：文件名（file）和模式（mode）
语法：
open(file, mode=’r’)
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参数：
默认为t模式（文本模式），如果要以二进制模式打开，加上b

t–文本模式（默认）
x–写模式，新建一个文件，如果该文件已存在则会报错
b–二进制模式
+–打开一个文件进行更新（可读可写）
U–通用换行模式（不推荐）
r–以只读方式打开文件。文件的指针将会放在文件的开头，这是默认模式
rb–以只读、二进制格式打开一个文件。文件指针将会放在文件的开头，这是默认模式，一般用于非文本文件如图片等。
r+–打开一个文件用于读写。文件指针将会放在文件的开头
rb+–以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w–打开一个文件只用于写入。如果该文件已存在则打开文件，并从头开始编辑，即原有内容会被删除。如果该文件不存在，则创建新文件。
wb–以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编写，即原有内容会被删除。如果该文件不存在，则创建新文件。一般用于非文本文件如图片等。
w+–打开一个文件用于读写。如果该文件已存在则打开文件，并从头开始编辑，即原有内容会被删除。如果该文件不存在，则创建新文件。
wb+–以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从头开始编辑，即原有内容会被删除。如果该文件不存在，则创建新文件。一般用于非文本文件如图片等。
a–打开一个文件用于追加。如果该文件已经存在，文件指针将会放在文件的结尾，也就是说，新的内容会被写入到已有内容之后。如果该文件不存在，则创建新文件进行写入。
ab–以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾，也就是说，新的内容会被写入到已有内容之后。如果该文件不存在，则创建新文件进行写入。
a+–打开一个文件用于读写。如果该我呢见已存在，文件指针将会放在文件的结尾。文件打开时为追加模式。如果文件不存在，则创建新文件用于读写。
ab+–以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，则创建新文件用于读写。
返回值：
<_io.TextIOWrapper name=’users.txt’ mode=’r’ encoding=’cp936′>
”’
f = open(‘users.txt’)
print(f)
# <_io.TextIOWrapper name=’users.txt’ mode=’r’ encoding=’cp936′>
print(f.read())
# admin:Qwer1234
# test:test123


# 49、ord()：
”’
描述：
ord()函数是chr()函数（对于8位的ASCII字符串）的配对函数，它以一个字符串（Unicode字符）
作为参数，返回对应的ASCII数值，或者Unicode数值。
语法：
odr(c)
参数：
c–字符
返回值：
返回值是对应的十进制整数
”’
print(ord(‘a’)) # 97
print(ord(‘A’)) # 65


# 50、pow()：
”’
描述：
pow()方法返回x^y（x的y次方）的值
语法：
math模块pow()方法的语法：
import math

math.pow(x, y)
内置的pow()方法的语法：
pow(x, y[, z])
函数是机选x的y次方，如果z存在，则再对结果进行取模，其结果等效于pow(x, y) % z
注意：
pow()通过内置的方法直接调用，内置方法会把参数作为整型int，
而math模块则会把参数转换为浮点型float。
参数：
x–数值表达式
y–数值表达式
z–数值表达式
返回值：
返回x^y（x的y次方）的值
”’
import math # 导入math模块

# 使用math模块的pow()函数
print(‘math.pow(100, 2):’, math.pow(100, 2)) # math.pow(100, 2): 10000.0
print(‘math.pow(100, -2):’, math.pow(100, –2)) # math.pow(100, -2): 0.0001
print(‘math.pow(2, 4):’, math.pow(2, 4)) # math.pow(2, 4): 16.0
# 使用内置的pow()函数
print(‘pow(100, 2):’, pow(100, 2)) # pow(100, 2): 10000
print(‘pow(100, -2):’, pow(100, –2)) # pow(100, -2): 0.0001
print(‘pow(2, 4):’, pow(2, 4)) # pow(2, 4): 16


# 51、print()：
”’
描述：
用于打印输出，最常见的一个函数
在Python3.3版增加了flush关键字参数。
print()在Python3.x是一个函数，在Python2.x只是一个关键字，不是函数
语法：
print(*objects, sep=’ ‘, end=’\n‘, file=sys.stdout, flush=False)
参数：
objects–复数，表示可以一次输出多个对象。输出多个对象时，需要使用逗号（,）分隔。
sep–分隔符，用来间隔多个对象，默认是一个空格。
end–结尾符，用来设定以什么结尾，默认是一个换行符\n，可以换成其他字符串。
file–要写入的文件对象。
flush–输出是否被缓存，通常决定于file，但如果flush关键字参数为True，流会被强制刷新。
返回值：
无
”’
print(123456789) # 123456789
print(type(123456789)) # <class ‘int’>
print(‘hello world’) # hello world
print(type(‘hello world’)) # <class ‘str’>
print(‘www’, ‘ ‘, ‘com’, sep=‘.’) # 设置分隔符


### 使用flush参数生成一个Loading的效果
import time

print(‘— RUNOOB EXAMPLE ：Loading 效果—‘)
print(‘Loading’, end=”)
for i in range(3):
print(‘.’, end=”, flush=True)
time.sleep(0.5)
print()

# 52、property()：
”’
https://www.runoob.com/python/python-func-property.html
http://c.biancheng.net/view/2286.html
描述：
在新式类中返回属性值
语法：
属性名= property([fget=None[, fset=None[, fdel=None[, docstring=None]]]])
参数：
fget–获取属性值的函数
fset–设置属性值的函数
fdel–删除属性值函数
docstring–文档字符串，即属性描述信息，用于说明此函数的作用

在使用property() 函数时，以上4 个参数可以仅指定第1 个、或者前2 个、或者前3 个，当前也可以全部指定。也就是说，property() 函数中参数的指定并不是完全随意的。
返回值：
返回新式类属性
”’
class C(object):
def __init__(self):
self._x = None

def getx(self):
return self._x

def setx(self, value):
self._x = value

def delx(self):
del self._x

x = property(getx, setx, delx, “I’m the ‘x’ property.”)
”’
如果c是C的实例化，则c.x将触发getter，c.x = value触发setter，del c.x触发deleter。
如果给定doc参数，其将称为这个属性值的
”’
class CLanguage:
# 构造函数
def __init__(self, n):
self.__name = n

# 设置name属性值的函数
def setname(self, n):
self.__name = n
# 访问name属性值的函数
def getname(self):
# 注意：
# 由于getname()方法中需要返回name属性，如果使用self.name的话，其本身又被调用getname()，这样会陷入死循环。
# 为了避免这种情况，程序中的name属性不能是公有属性，必须是私有属性__name或受保护的属性_name，
# 否则将产生死循环并报错RecursionError: maximum recursion depth exceeded。
return self.__name
# 删除name属性值的函数
def delname(self):
self.__name = ‘attribute has been deleted!’
# 或
# del self.__name # 使用该语句则抛出异常：AttributeError: ‘CLanguage’ object has no attribute ‘_CLanguage__name’

# 为name属性配置property()函数
name = property(getname, setname, delname, ‘此处为property函数的docstring说明…’)

# 调取说明文档的2种方式
print(CLanguage.name.__doc__) # 此处为property函数的docstring说明…
help(CLanguage.name)
”’
打印结果：
Help on property:

此处为property函数的docstring说明…
”’
clang = CLanguage(‘C语言中文网‘)
# 调用getname()方法，获取属性值__name
print(clang.name) # C语言中文网

# 调用setname()方法，设置属性值__name
clang.name = ‘Python教程‘
print(clang.name) # Python教程

# 调用delname()方法，删除属性值__name
del clang.name
print(clang.name) # property has been deleted!
”’
当然，property()函数也可以少传入几个参数，以上面程序为例，我们可以将property()函数修改如下
name = property(getname, setname)
这意味着，name是一个可读写的属性，但不能删除，因为property()函数中并没有为name配置用于该属性的函数方法。
也就是说，即便Clanguage类中设计有delname()函数，这种情况也不能用来删除name属性，否则会报错AttributeError: can’t delete attribute。

同理，还可以像如下这样使用property()函数：
name = property(getname) # name属性可读、不可写、不可删除
name = property(getname, setname, delname) # name属性可读、可写、可删除，但没有说明文档
”’