变量

1、变量赋值

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

等号（=）用来给变量赋值。

等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。

#!/usr/bin/python3

counter = 100          # 整型变量，定义并赋值
miles   = 1000.0       # 浮点型变量
name    = "runoob"     # 字符串

print (counter)
print (miles)
print (name)
del name　　　　　　　　 #删除变量name

只读变量：

用私有属性+@property定义只读属性, 需要预先定义好属性名, 然后实现对应的getter方法.

class Vector2D(object):
 def __init__(self, x, y):
 self.__x = float(x)
 self.__y = float(y)
 
 @property
 def x(self):
 return self.__x
 @property
 def y(self):
 return self.__y
 
if __name__ == "__main__":
 v = Vector2D(3, 4)
 print(v.x, v.y)
 v.x = 8 # error will be raised.

2、变量类型

（1）数字类型

（2）字符串类型

字符串

A、字符串的定义

• 字符串 就是 一串字符，是编程语言中表示文本的数据类型
• 在 Python 中可以使用 一对双引号 " 或者 一对单引号 ' 定义一个字符串
• 可以使用 索引 获取一个字符串中 指定位置的字符，索引计数从 0 开始
• 也可以使用 for 循环遍历 字符串中每一个字符

#!/usr/bin/env python3
# -*-coding:utf-8-*-

"""
@author:fyh
@time:2019/5/31
"""


str1 = "hello python"

for c in str1:
    print(c, end='\t')
    
# 运行结果：h    e    l    l    o         p    y    t    h    o    n

B、字符串的常用操作

#!/usr/bin/env python3
# -*-coding:utf-8-*-

"""
@author:fyh
@time:2019/5/31
"""

# 1   * 重复输出字符串
print('hello' * 2)

# 2 [] ,[:] 通过索引获取字符串中字符
print('helloworld'[2:])

# 3 in  成员运算符 - 如果字符串中包含给定的字符返回 True
print('el' in 'hello')

# 4 %   格式字符串
print('alex is a good teacher')
print('%s is a good teacher' % 'alex')

# 5 +   字符串拼接
a = '123'
b = 'abc'
c = '789'
d1 = a + b + c
print(d1)  # +效率低,该用join

# join效率高
d2 = ''.join([a, b, c])
print(d2)

C、字符串相关的函数

　　常用函数

# string.upper() 转换 string 中的小写字母为大写
# string.lower() 转换 string 中所有大写字符为小写
# string.startswith(obj, beg=0,end=len(string)) 检查字符串是否是以obj开头，是则返回True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
# string.endswith(obj, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
# string.replace(str1, str2, num=string.count(str1)) 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
# string.strip([obj]) 在 string 上执行 lstrip()和 rstrip() 去除空格
# string.split(str="", num=string.count(str)) 以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串
# string.find(str, beg=0, end=len(string)) 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
# string.encode(encoding='UTF-8', errors='strict') 以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是ignore或者replace
# string.decode(encoding='UTF-8', errors='strict') 以 encoding 指定的编码格式解码 string，如果出错默认报一个ValueError的异常，除非errors指定的是'ignore'或 者'replace'
# string.join(seq) 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
# string.format()  格式化输出

　　其他函数

# string.capitalize() 把字符串的第一个字符大写
# string.center(width) 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
# string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
# string.expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是8。
# string.index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在 string中会报一个异常.
# string.isalnum() 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
# string.isalpha() 如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
# string.isdecimal() 如果 string 只包含十进制数字则返回 True 否则返回 False.
# string.isdigit() 如果 string 只包含数字则返回 True 否则返回 False.
# string.islower() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
# string.isnumeric() 如果 string 中只包含数字字符，则返回 True，否则返回 False
# string.isspace() 如果 string 中只包含空格，则返回 True，否则返回 False.
# string.istitle() 如果 string 是标题化的(见 title())则返回 True，否则返回 False
# string.isupper() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
# string.ljust(width) 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
# string.lstrip() 截掉 string 左边的空格
# string.maketrans(intab, outtab]) maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
# max(str) 返回字符串 str 中最大的字母。
# min(str) 返回字符串 str 中最小的字母。
# string.partition(str) 有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
# string.rfind(str, beg=0,end=len(string) ) 类似于 find()函数，不过是从右边开始查找.
# string.rindex( str, beg=0,end=len(string)) 类似于 index()，不过是从右边开始.
# string.rjust(width) 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
# string.rpartition(str) 类似于 partition()函数,不过是从右边开始查找.
# string.rstrip() 删除 string 字符串末尾的空格.
# string.splitlines(num=string.count('\n')) 按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行.
# string.swapcase() 翻转 string 中的大小写
# string.title() 返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
# string.translate(str, del="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中

D、字符串切片

• 切片 使用 索引值 来限定范围，根据 步长 从原序列中 取出一部分 元素组成新序列
• 切片 方法适用于 字符串、列表、元组
• 切片的语法表达式为：[start_index : end_index : step]，其中：
  • start_index：起始索引
  • end_index：结束索引
  • step：步长

切片操作是指按照步长，截取从起始索引到结束索引，但不包含结束索引（也就是结束索引减1）的所有元素。

切片不会改变原对象，而是重新生成了一个新的对象

#!/usr/bin/env python3
# -*-coding:utf-8-*-

"""
@author:fyh
@time:2019/5/31
"""

str1 = "hello world"


print(str1[1:6])
# 结果是ello

print(str1[1:6:2])
# 结果是el

print(str1[2:])
# 结果是llo world
# 保留start_index，但省略end_index，这样会从起始索引开始，切到最后一个元素为止

print(str1[:5])
# 结果是hello
# 省略start_index，保留end_index，这样会从第一个元素开始，切到end_index - 1的元素为止

print(str1[-1:-6:-1])
# 结果是dlrow

print(str1[1:6:-1])
# 结果为空
# 切片时,一定要保证start_index到end_index的方向与步长step的方向同向，否则会切出空的序列

E、字符串拼接

Python的字符串格式化有三种方式: 百分号方式、format方式、f-strings方式

百分号方式

格式：%[(name)][flags][width].[precision]typecode

• (name) 可选，用于选择指定的key

• flags 可选，可供选择的值有:

• • + 右对齐；正数前加正好，负数前加负号；
  • - 左对齐；正数前无符号，负数前加负号；
  • 空格 右对齐；正数前加空格，负数前加负号；
  • 0 右对齐；正数前无符号，负数前加负号；用0填充空白处

• width 可选，占有宽度

• precision 可选，小数点后保留的位数

• typecode 必选

• • s，获取传入对象的__str__方法的返回值，并将其格式化到指定位置
  • r，获取传入对象的__repr__方法的返回值，并将其格式化到指定位置
  • c，整数：将数字转换成其unicode对应的值，10进制范围为 0 <= i <= 1114111（py27则只支持0-255）；字符：将字符添加到指定位置
  • o，将整数转换成 八进制表示，并将其格式化到指定位置
  • x，将整数转换成十六进制表示，并将其格式化到指定位置
  • d，将整数、浮点数转换成 十 进制表示，并将其格式化到指定位置
  • e，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）
  • E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）
  • f， 将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）
  • F，同上
  • g，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）
  • G，自动调整将整数、浮点数转换成浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）
  • %，当字符串中存在格式化标志时，需要用 %%表示一个百分号

注：Python中百分号格式化是不存在自动将整数转换成二进制表示的方式

tpl = "i am %s" % "alex"
tpl = "i am %s age %d" % ("alex", 18)
tpl = "i am %(name)s age %(age)d" % {"name": "alex", "age": 18}
tpl = "percent %.2f" % 99.97623
tpl = "i am %(pp).2f" % {"pp": 123.425556, }
tpl = "i am %.2f %%" % 123.425556

format方式

格式：[[fill]align][sign][#][0][width][,][.precision][type]

• • fill 【可选】空白处填充的字符

  • align 【可选】对齐方式（需配合width使用）

  • • <，内容左对齐
    • >，内容右对齐(默认)
    • ＝，内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。 即使：符号+填充物+数字
    • ^，内容居中

  • sign 【可选】有无符号数字

  • • +，正号加正，负号加负；
    • -，正号不变，负号加负；
    • 空格 ，正号空格，负号加负；

  • # 【可选】对于二进制、八进制、十六进制，如果加上#，会显示 0b/0o/0x，否则不显示

  • ， 【可选】为数字添加分隔符，如：1,000,000

  • width 【可选】格式化位所占宽度

  • .precision 【可选】小数位保留精度

  • type 【可选】格式化类型

  • • 传入” 字符串类型 “的参数

    • • s，格式化字符串类型数据
      • 空白，未指定类型，则默认是None，同s

    • 传入“ 整数类型 ”的参数

    • • b，将10进制整数自动转换成2进制表示然后格式化
      • c，将10进制整数自动转换为其对应的unicode字符
      • d，十进制整数
      • o，将10进制整数自动转换成8进制表示然后格式化；
      • x，将10进制整数自动转换成16进制表示然后格式化（小写x）
      • X，将10进制整数自动转换成16进制表示然后格式化（大写X）
• • • 传入“ 浮点型或小数类型 ”的参数
• • • • e， 转换为科学计数法（小写e）表示，然后格式化；
      • E， 转换为科学计数法（大写E）表示，然后格式化;
      • f ， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
      • F， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
      • g， 自动在e和f中切换
      • G， 自动在E和F中切换
      • %，显示百分比（默认显示小数点后6位）

案例：

tpl = "i am {}, age {}, {}".format("seven", 18, 'alex')
tpl = "i am {}, age {}, {}".format(*["seven", 18, 'alex'])
tpl = "i am {0}, age {1}, really {0}".format("seven", 18)
tpl = "i am {0}, age {1}, really {0}".format(*["seven", 18])
tpl = "i am {name}, age {age}, really {name}".format(name="seven", age=18) 
tpl = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18}) 
tpl = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])
tpl = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)
tpl = "i am {:s}, age {:d}".format(*["seven", 18])
tpl = "i am {name:s}, age {age:d}".format(name="seven", age=18)
tpl = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18})
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
tpl = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)
tpl = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)

f-strings方式

f-strings 提供一种简洁易读的方式, 可以在字符串中包含 Python 表达式. f-strings 以字母 'f' 或 'F' 为前缀, 格式化字符串使用一对单引号、双引号、三单引号、三双引号. 格式化字符串中。

#!/usr/bin/env python
# -*-coding:utf-8-*-

"""
@author:fyh
@time:2019/6/5
"""
name = '豪仔'
age = 26
format_string1 = f'我的名字是 {name}, 我的年龄是 {age}'
print(format_string1)  # 我的名字是 豪仔, 我的年龄是 26

format_string2 = f"我的名字是 {name}, 我的年龄是 {age}"
print(format_string2)   # 我的名字是 豪仔, 我的年龄是 26

format_string3 = F'''我的名字是 {name}, 我的年龄是 {age}'''
print(format_string3)  # 我的名字是 豪仔, 我的年龄是 26

format_string4 = F"""我的名字是 {name}, 我的年龄是 {age}"""
print(format_string4)   # 我的名字是 豪仔, 我的年龄是 26

# 花括号中的数字会先运算
format_string5 = f'3 + 5 = {3 + 5}'
print(format_string5)   # 3 + 5 = 8

a = 10
b = 20
format_string6 = f'3 + 5 = {a + b}'
print(format_string6)   # 3 + 5 = 30

# 两个花括号会被替换为一个花括号, 注意{{}} 不表示表达式
format_string7 = F'我的名字是 {{name}}, 我的年龄是 {{age}}'
print(format_string7)

（3）字节型(bytes)

Python3最重要的新特性之一是对字符串和二进制数据流做了明确的区分。文本总是Unicode，由str类型表示，二进制数据则由bytes类型表示。Python3不会以任意隐式的方式混用str和bytes，你不能拼接字符串和字节流，也无法在字节流里搜索字符串（反之亦然），也不能将字符串传入参数为字节流的函数（反之亦然）。

A、回顾编码的发展史

在计算机历史的早期，美国为代表的英语系国家主导了整个计算机行业，26个英文字母组成了多样的英语单词、语句、文章。因此，最早的字符编码规范是ASCII码，一种8位即1个字节的编码规范，它可以涵盖整个英语系的编码需要。

编码是什么？编码就是把一个字符用一个二进制来表示。我们都知道，所有的东西，不管是英文、中文还是符号等等，最终存储在磁盘上都是01010101这类东西。在计算机内部，读取和存储数据归根结底，处理的都是0和1组成的比特流。问题来了，人类看不懂这些比特流，如何让这些010101对人类变得可读呢？于是出现了字符编码，它是个翻译机，在计算机内部某个地方，透明的帮我们将比特流翻译成人类可以直接理解的文字。对于一般用户，不需要知道这个过程是什么原理，是怎么执行的。但是对于程序员却是个必须搞清楚的问题。

以ASCII编码为例，它规定1个字节8个比特位代表1个字符的编码，也就是“00000000”这么宽，一个一个字节的解读。例如：01000001表示大写字母A，有时我们会“偷懒"的用65这个十进制来表示A在ASCII中的编码。8个比特位，可以没有重复的最多表示2的8次方(255)个字符。

后来，计算机得到普及，中文、日文、韩文等等国家的文字需要在计算机内表示，ASCII的255位远远不够，于是标准组织制定出了叫做UNICODE的万国码，它规定任何一个字符（不管哪国的）至少以2个字节表示，可以更多。其中，英文字母就是用2个字节，而汉字是3个字节。这个编码虽然很好，满足了所有人的要求，但是它不兼容ASCII，同时还占用较多的空间和内存。因为，在计算机世界更多的字符是英文字母，明明可以1个字节就能够表示，非要用2个。

于是UTF-8编码应运而生，它规定英文字母系列用1个字节表示，汉字用3个字节表示等等。因此，它兼容ASCII，可以解码早期的文档。UTF-8很快就得到了广泛的应用。

在编码的发展历程中，我国还创造了自己的编码方式，例如GBK，GB2312，BIG5。他们只局限于在国内使用，不被国外认可。在GBK编码中，中文汉字占2个字节。

B、bytes和str的异同

回到bytes和str的身上。bytes是一种比特流，它的存在形式是01010001110这种。我们无论是在写代码，还是阅读文章的过程中，肯定不会有人直接阅读这种比特流，它必须有一个编码方式，使得它变成有意义的比特流，而不是一堆晦涩难懂的01组合。因为编码方式的不同，对这个比特流的解读也会不同，对实际使用造成了很大的困扰。下面让我们看看Python是如何处理这一系列编码问题的：

>>> s = "中文"
>>> s
'中文'
>>> type(s)
<class 'str'>
>>> b = bytes(s, encoding='utf-8')
>>> b
b'\xe4\xb8\xad\xe6\x96\x87'
>>> type(b)
<class 'bytes'>

从例子可以看出，s是个字符串类型。Python有个内置函数bytes()可以将字符串str类型转换成bytes类型，b实际上是一串01的组合，但为了在ide环境中让我们相对直观的观察，它被表现成了b'\xe4\xb8\xad\xe6\x96\x87'这种形式，开头的b表示这是一个bytes类型。\xe4是十六进制的表示方式，它占用1个字节的长度，因此”中文“被编码成utf-8后，我们可以数得出一共用了6个字节，每个汉字占用3个，这印证了上面的论述。在使用内置函数bytes()的时候，必须明确encoding的参数，不可省略。

我们都知道，字符串类str里有一个encode()方法，它是从字符串向比特流的编码过程。而bytes类型恰好有个decode()方法，它是从比特流向字符串解码的过程。除此之外，我们查看Python源码会发现bytes和str拥有几乎一模一样的方法列表，最大的区别就是encode和decode。

从实质上来说，字符串在磁盘上的保存形式也是01的组合，也需要编码解码。

如果，上面的阐述还不能让你搞清楚两者的区别，那么记住下面两几句话：

1. 在将字符串存入磁盘和从磁盘读取字符串的过程中，Python自动地帮你完成了编码和解码的工作，你不需要关心它的过程。
2. 使用bytes类型，实质上是告诉Python，不需要它帮你自动地完成编码和解码的工作，而是用户自己手动进行，并指定编码格式。
3. Python已经严格区分了bytes和str两种数据类型，你不能在需要bytes类型参数的时候使用str参数，反之亦然。这点在读写磁盘文件时容易碰到。

在bytes和str的互相转换过程中，实际就是编码解码的过程，必须显式地指定编码格式。

#!/usr/bin/env python3
# -*-coding:utf-8-*-

"""
@author:fyh
@time:2019/5/31
"""
# gbk编码的bytes
b = bytes('中国', encoding='gbk')
print(b)        # b'\xd6\xd0\xb9\xfa'
print(type(b))  # <class 'bytes'>

str1 = str(b)
print(str1)     # b'\xd6\xd0\xb9\xfa'
print(type(str1))   # <class 'str'>

# 指定编码格式
str2 = str(b, encoding='gbk')
print(str2)     # 中国
print(type(str2))   # <class 'str'>

# 再把字符串str2转换为utf8编码格式的bytes类型:
b2 = bytes(str2, encoding='utf8')
print(b2)       # b'\xe4\xb8\xad\xe5\x9b\xbd'

C、encode和decode

上面说过了，python3默认的编码时Unicode，用字符串表示，二进制数据由bytes类型表示。

• encode：将str转换为bytes，是一个编码的过程
• decode：将bytes转换为str，是一个解码的过程

#!/usr/bin/env python3
# -*-coding:utf-8-*-

"""
@author:fyh
@time:2019/5/31
"""

"""
其中decode()与encode()方法可以接受参数， 其声明分别为:
    bytes.decode(encoding="utf-8", errors="strict")
    str.encode(encoding="utf-8", errors="strict")

        其中 encoding是指在解码/编码(动词)过程中使用的字符编码(名词)
        
        errors是指错误的处理方案,errrors参数默认值是strict(严格的)意味着如果编解码出错将会抛出UnicodeError

        如果想忽略编解码错误 可以将errors设置为ignore
"""


# 编码 encode
str1 = "中国"
 
str1_utf8 = str1.encode(encoding='utf8')
print(str1_utf8)        # b'\xe4\xb8\xad\xe5\x9b\xbd'
print(type(str1_utf8))  # <class 'bytes'>

str1_gbk = str1.encode(encoding="gbk")
print(str1_gbk)         # b'\xd6\xd0\xb9\xfa'
print(type(str1_gbk))   # <class 'bytes'>
 

# 解码 decode
str2 = str1_utf8.decode(encoding="utf8")
print(str2)     # 中国
print(type(str2))   # <class 'str'>

str3 = str1_gbk.decode(encoding="gbk")
print(str3)         # 中国
print(type(str3))   # <class 'str'>

编码和解码时，对应的编码方式要一致

对数据的编码解码工作是通过返回值查看到最终结果的，前面的数据对象并不受影响

（4）列表类型

列表

（5）元组类型

元组

（6）字典类型

字典

（7）集合类型

3、变量范围

内建对象类型：__built__。

全局变量可以在局部里使用，局部变量不可以在全局使用

全局变量：就是在函数外设置的变量，是在整个文件代码中可以使用的

局部变量：就是定义函数里面设置的变量，只能在定义函数内部使用，要想整个文件代码中可以使用就必须转换成全局变量。

class A():
    def __init__(self):
        print('A')
class B():
    def __init__(self):
        print('B')
print(globals())
globals()['A']()
globals()['B']()

输出

{'__name__': '__main__', '__doc__': 'Automatically created module for IPython interactive environment', '__package__': None, '__loader__': None, '__spec__': None, 
'__builtin__': <module 'builtins' (built-in)>, '__builtins__': <module 'builtins' (built-in)>, 
'_ih': ['', "class A():\n    def __init__(self):\n        print('A')\nclass B():\n    def __init__(self):\n        print('B')\nprint(globals())\nglobals()['A']()\nglobals()['B']()"], 
'_oh': {}, 
'_dh': ['/root/python/conda'], 
'In': ['', "class A():\n    def __init__(self):\n        print('A')\nclass B():\n    def __init__(self):\n        print('B')\nprint(globals())\nglobals()['A']()\nglobals()['B']()"], 
'Out': {}, 
'get_ipython': <bound method InteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7f5bf168b730>>, 
'exit': <IPython.core.autocall.ZMQExitAutocall object at 0x7f5bf16638b0>, 
'quit': <IPython.core.autocall.ZMQExitAutocall object at 0x7f5bf16638b0>, 
'_': '', '__': '', '___': '', '_i': '', '_ii': '', '_iii': '', 
'_i1': "class A():\n    def __init__(self):\n        print('A')\nclass B():\n    def __init__(self):\n        print('B')\nprint(globals())\nglobals()['A']()\nglobals()['B']()", 
'A': <class '__main__.A'>, 
'B': <class '__main__.B'>}
A
B

常见全局变量介绍

(1)查看内置全局变量，以字典方式返回内置全局变量：print(vars())
(2)__name__:
全局变量写在入口文件里，只有执行入口文件时的返回值才是__main__  ，如果入口文件被
导入到别的文件里，此时入口文件的__name__返回值就不在是__main__，而是如果文件的路
径加入口文件名称，所以我们可以用__name__全局变量来防止别人盗链入口文件
(3)__doc__
获取文件的注释
(4)__package__
获取导入文件的路径，多层目录以点分割，注意：对当前文件返回None
(5)__builtins__
内置函数在这里面：dir(__builtins__)
(6) __file__ 
获取当前文件的绝对路径
(7)__cached__ ：
获取导入文件的缓存路径

常见内建函数

数学运算(7个)

类型转换(24个)

序列操作(8个)

对象操作(7个)

反射操作(8个)

变量操作(2个)

交互操作(2个)

文件操作(1个)

编译执行(4个)

装饰器(3个)

内建函数详解

变量作用域

4、传递参数

函数和类可以进行参数传递。

5、标准输入输出

（1）input

input(prompt=None, /)
    Read a string from standard input.  The trailing newline is stripped.

    The prompt string, if given, is printed to standard output without a
    trailing newline before reading input.

    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
    On *nix systems, readline is used if available.

（2）print

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.