format()数字格式化
下表展示了 str.format() 格式化数字的多种方法：
>>> print("{:.2f}".format(3.1415926))
3.14
| 数字 |
格式 |
输出 |
描述 |
| 3.1415926 |
{:.2f} |
3.14 |
保留小数点后两位 |
| 3.1415926 |
{:+.2f} |
+3.14 |
带符号保留小数点后两位 |
| -1 |
{:+.2f} |
-1.00 |
带符号保留小数点后两位 |
| 2.71828 |
{:.0f} |
3 |
不带小数，四舍五入 |
| 5 |
{:0>4d} |
05 |
数字补0 (填充左边, 宽度为4) |
| 5 |
{:x<4d} |
5xxx |
数字补x (填充右边, 宽度为4) |
| 10 |
{:x<4d} |
10xx |
数字补x (填充右边, 宽度为4) |
| 1000000 |
{:,} |
1,000,000 |
以逗号分隔的数字格式 |
| 0.25 |
{:.2%} |
25.00% |
百分比格式 |
| 1000000000 |
{:.2e} |
1.00e+09 |
指数记法 |
| 13 |
{:>10d} |
13 |
右对齐 (默认, 宽度为10) |
| 13 |
{:<10d} |
13 |
左对齐 (宽度为10) |
| 13 |
{:^10d} |
13 |
中间对齐 (宽度为10) |
| 11 |
'{:b}'.format(11) '{:d}'.format(11) '{:o}'.format(11) '{:x}'.format(11) '{:#x}'.format(11) '{:#X}'.format(11) |
1011 11 13 b 0xb 0XB |
进制 |
^, <, > 分别是居中、左对齐、右对齐，后面带宽度，
: 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
+ 表示在正数前显示 +，负数前显示 -；
（空格）表示在正数前加空格
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属性可读、可写、可删除，但没有说明文档
'''