Python基础-内置函数&关键字（笔记）

​ Python基础-内置函数&关键字

目录

abs() - 求绝对值

绝对值或复数的模

abs(-10)

10

abs(1+2j)

2.23606797749979

all() - 元素都为真

接受一个迭代器，如果迭代器的所有元素都为真，那么返回True，否者返回 False。

all([1, 2, 0, 4])

False

all([1, 2, 4])

True

any() - 元素至少一个为真

接受一个迭代器，如果迭代器至少有一个元素为真，那么返回True，否者返回False。

any([0, 0, [], [1, 0], {}, ()])

True

any([0, {}, [], ()])

False

ascii() - 展示对象

调用对象的repr()方法，获得该方法的返回值，下面的例子返回值为字符串。

class Student():
    def __init__(self, id, name):
        self.id = id
        self.name = name
    def __repr__(self):
        return 'id = ' + self.id + ', name = ' + self.name

dafei = Student(id='001', name='dafei')
print(dafei)

id = 001, name = dafei

ascii(dafei)

'id = 001, name = dafei'

bin() - 十进制转二进制

bin(8)

'0b1000'

oct() - 十进制转八进制

oct(8)

'0o10'

hex() - 十进制转十六进制

hex(11)

'0xb'

bool() - 布尔判断

测试一个对象是True，还是False。

bool([0,1,0])

True

bool(())

False

bool({1:0})

True

bytes() - 字符串转字节

将一个字符串转成字节类型。

s = "liubei"
bytes(s, encoding='utf-8')

b'liubei'

str() - 转为字符串

str(888)

'888'

callable() - 是否可调用

判断对象是否可被调用，能被调用的对象就是一个callable对象，比如函数str,int等都是可被调用的，但是4中的dafei实例时不可调用的：

callable(str)

True

callable(float)

True

callable(bytes)

True

callable(dafei)

False

如果想让dafei实例能被调用dafei(),需要重写Student类的call方法：

class Student():
    def __init__(self, id, name):
        self.id = id
        self.name = name
    def __repr__(self):
        return 'id = '+self.id +', name = '+self.name
    def __call__(self):
        print('I can be called!')
        print(f'my name is {self.name}')
        

t = Student('001', 'dafei')

t()

I can be called!
my name is dafei

chr() - 十进制转ASCII字符

查看十进制整数对应的ASCII字符

chr(88)

'X'

chr(65)

'A'

ord() - ASCII字符转十进制

ord('X')

88

ord('z')

122

classmethod - 类方法

classmethod装饰器对应的函数不需要实例化，不需要self参数，但第一个参数需要时表示自身类的cls参数，可以来调用类的属性，类的方法，实例化对象等。

class Student():
    def __init__(self, id, name):
        self.id = id
        self.name = name
    def __repr__(self):
        return 'id = '+self.id +', name = '+self.name
    @classmethod
    def f(cls):
        print(cls)

compile() - 执行字符串表示的代码

将字符串编译成python能识别或执行的代码，也可以将文字读成字符串再编译。

描述
compile() 函数将一个字符串编译为字节代码。

语法
以下是 compile() 方法的语法:

compile(source, filename, mode[, flags[, dont_inherit]])
参数

  • source -- 字符串或者AST（Abstract Syntax Trees）对象。。
  • filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
  • mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
  • flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
  • flags和dont_inherit是用来控制编译源码时的标志
s = "print('hello world!')"
r = compile(s, "<string>", "exec")
r

<code object <module> at 0x000002C585CA3450, file "<string>", line 1>

exec(r)

hello world!

complex() - 创建复数

complex(1,2)

(1+2j)

delattr() - 动态删除属性

删除对象的属性

delattr(dafei, 'id')

hasattr(dafei, 'id')

False

dict() - 转为字典

创建数据字典

dict()

{}

dict(a=1, b=2)

{'a': 1, 'b': 2}

dict(zip(['a', 'b'], [1, 2]))

{'a': 1, 'b': 2}

dict([('a', 1), ('b', 2)])

{'a': 1, 'b': 2}

dir() - 一键查看对象所有方法

不带参数时返回当前范围内的变量、方法和定义的类型列表；带参数时返回参数的属性，方法列表。

dir(dafei)

['__class__',
 '__delattr__',
 '__dict__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__le__',
 '__lt__',
 '__module__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 '__weakref__',
 'name']

dir()

['In',
 'Out',
 'Student',
 '_',
 '_1',
 '_10',
 '_11',
 '_12',
 '_13',
 '_14',
 '_15',
 '_16',
 '_17',
 '_18',
 '_19',
 '_2',
 '_20',
 '_21',
 '_25',
 '_26',
 '_27',
 '_28',
 '_3',
 '_30',
 '_32',
 '_34',
 '_35',
 '_36',
 '_37',
 '_38',
 '_39',
 '_4',
 '_5',
 '_6',
 '_9',
 '__',
 '___',
 '__builtin__',
 '__builtins__',
 '__doc__',
 '__loader__',
 '__name__',
 '__package__',
 '__spec__',
 '_dh',
 '_i',
 '_i1',
 '_i10',
 '_i11',
 '_i12',
 '_i13',
 '_i14',
 '_i15',
 '_i16',
 '_i17',
 '_i18',
 '_i19',
 '_i2',
 '_i20',
 '_i21',
 '_i22',
 '_i23',
 '_i24',
 '_i25',
 '_i26',
 '_i27',
 '_i28',
 '_i29',
 '_i3',
 '_i30',
 '_i31',
 '_i32',
 '_i33',
 '_i34',
 '_i35',
 '_i36',
 '_i37',
 '_i38',
 '_i39',
 '_i4',
 '_i40',
 '_i5',
 '_i6',
 '_i7',
 '_i8',
 '_i9',
 '_ih',
 '_ii',
 '_iii',
 '_oh',
 'dafei',
 'exit',
 'get_ipython',
 'quit',
 'r',
 's',
 't']

divmod() - 取商和余数

divmod(9, 2)

(4, 1)

enumerate() - 枚举对象

描述:
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

语法:
以下是 enumerate() 方法的语法:
enumerate(sequence, [start=0])

参数:

  • sequence -- 一个序列、迭代器或其他支持迭代对象。
  • start -- 下标起始位置。

返回值:
返回 enumerate(枚举) 对象。

s = ['a', 'b', 'c']
for i, s in enumerate(s, 1):
    print(i, s)

1 a
2 b
3 c

eval() - 计算表达式

描述:
eval() 函数用来执行一个字符串表达式，并返回表达式的值。

语法:
以下是 eval() 方法的语法:
eval(expression[, globals[, locals]])

参数:

  • expression -- 表达式。
  • globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
  • locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

返回值:
返回表达式计算结果。

n = 100
eval("n + 100")

200

eval("pow(2, 2)")

4

x = 2
eval("x + 2")

4

getsizeof() - 查看变量所占字节数

import sys

int = 100
bool = True
float = 1.1
str =""
list = []
tuple =()
dict = {}
set = set([])

显示大小
print("%s size is %d" %(type(int), sys.getsizeof(int)))
print("%s size is %d" %(type(bool), sys.getsizeof(bool)))
print("%s size is %d" %(type(float), sys.getsizeof(float)))
print("%s size is %d" %(type(str), sys.getsizeof(str)))
print("%s size is %d" %(type(list), sys.getsizeof(list)))
print("%s size is %d" %(type(tuple), sys.getsizeof(tuple)))
print("%s size is %d" %(type(dict), sys.getsizeof(dict)))
print("%s size is %d" %(type(set), sys.getsizeof(set)))

import sys
a = {'a':1, 'b':2.0}
sys.getsizeof(a)

232

filter() - 过滤器

描述：
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。
接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

语法：
以下是 filter() 方法的语法:
filter(function, iterable)

参数：

  • function -- 判断函数。
  • iterable -- 可迭代对象。

返回值：
返回一个迭代器对象

fil = filter(lambda x: x>10,[1,11,2,34,4,43,12])
fil

<filter at 0x2c585cba310>

list(fil)

[11, 34, 43, 12]

#求1-100之间的数的平方根是整数的数。
import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
 
tmplist = filter(is_sqr, range(1, 101))
newlist = list(tmplist)
newlist

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

float() - 转为浮点数

float(8)

8.0

format() - 字符串格式化

格式化输出字符重，format(value, format_spec)实质上是调用了value的format(format_spec)方法。

print("I am {0},age{1}".format("dafei",22))

I am dafei,age22

frozenset() - 创建一个不可修改的集合

描述:
frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

语法:
frozenset() 函数语法：
class frozenset([iterable])

参数:
iterable -- 可迭代的对象，比如列表、字典、元组等等。

返回值:
返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。

frozenset(range(10))

frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

gy = frozenset("guanyu")
gy

frozenset({'a', 'g', 'n', 'u', 'y'})

getattr() - 动态获取对象属性

获取对象的属性值

class Student():
    def __init__(self,id,name):
        self.id = id
        self.name = name
    def __repr__(self):
        return 'id = '+self.id +', name = '+self.name

dafei = Student(id='01', name='dafei')
getattr(dafei, 'id')#获取实例的属性值

'01'

hasattr() - 判断对象是否有这个属性

class Student():
    def __init__(self,id,name):
        self.id = id
        self.name = name
    def __repr__(self):
        return 'id = '+self.id +', name = '+self.name

dafei = Student(id='01', name='dafei')
hasattr(dafei, 'id')

True

hasattr(dafei, 'tel')

False

hash() - 返回对象的哈希值

hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
hash() 函数可以应用于数字、字符串和对象，不能直接应用于 list、set、dictionary。
在 hash() 对对象使用时，所得的结果不仅和对象的内容有关，还和对象的 id()，也就是内存地址有关。

class Test:
    def __init__(self, i):
        self.i = i
for i in range(10):
    t = Test(i)
    print(i,hash(t), id(t))

0 190464218965 3047427503440
1 190463357010 3047413712160
2 190464029835 3047424477360
3 190463369147 3047413906352
4 190463524178 3047416386848
5 190464246544 3047427944704
6 190463550440 3047416807040
7 190463681398 3047418902368
8 190463681476 3047418903616
9 190463499255 3047415988080

hash() 函数的对象字符不管有多长，返回的 hash 值都是固定长度的，也用于校验程序在传输过程中是否被第三方（木马）修改，如果程序（字符）在传输过程中被修改hash值即发生变化，如果没有被修改，则 hash 值和原始的 hash 值吻合，只要验证 hash 值是否匹配即可验证程序是否带木马（病毒）。

name1='正常程序代码'
name2='正常程序代码带病毒'
print(hash(name1)) # 2403189487915500087
print(hash(name2)) # -8751655075885266653

-2194181078385160891
8915465963883150582

hash(dafei)

190463553630

help() - 一键帮助

返回对象的帮助文档

help(dafei)

Help on Student in module __main__ object:

class Student(builtins.object)
 |  Student(id, name)
 |  
 |  Methods defined here:
 |  
 |  __init__(self, id, name)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)

​

id() - 返回对象的内存地址

id(dafei)

3047416858080

input() - 获取用户输入

input()

haha





'haha'

int() - 转为整数

int(x, base=10)，x可以为字符串或数值，将x转换为一个普通整数。如果参数时字符串，那么它可能包含符号和小数点。如果超出了普通整数的表示范围，一个长整数被返回。

int(23.32)

23

int('12',16)

18

isinstance() - 判断对象是否是类的实例

判断object是否为类classinfo的实例，是返回True

class Student():
    def __init__(self,id,name):
        self.id = id
        self.name = name
    def __repr__(self):
        return 'id = '+self.id +', name = '+self.name

dafei = Student(id='01', name='dafei')

isinstance(dafei, Student)
    

True

issubclass() - 父子类关系鉴定

描述:
issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。

语法:
以下是 issubclass() 方法的语法:
issubclass(class, classinfo)

参数:

  • class -- 类。
  • classinfo -- 类。

返回值:
如果 class 是 classinfo 的子类返回 True，否则返回 False。

class undergraduate(Student):
    def studyClass(self):
        pass
    def attendActivity(self):
        pass
    
issubclass(undergraduate, Student)

True

class A:
    pass
class B(A):
    pass
issubclass(B, A)   

True

issubclass(A, Student)

False

iter() - 创建迭代器

描述：
iter() 函数用来生成迭代器。

语法：
以下是 iter() 方法的语法:
iter(object[, sentinel])

参数：

  • object -- 支持迭代的集合对象。
  • sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。

返回值：
迭代器对象。

ls = [1, 2, 3]
for i in iter(ls):
    print(i)

1
2
3

class TestIter():
    def __init__(self):
        self.l = [1, 2, 3, 4, 5, 6]
        self.i = iter(self.l)
    def __call__(self):
        #定义了__call__方法的类的实例时可调用的
        item = next(self.i)
        print("__call__ is called, fowhich would return",item)
        return item
    def __iter__(self):
        #指出迭代协议（即定义有__iter__()函数）
        print("__iter__ is called!")
        return iter(self.l)

t = TestIter()
t()#因为实现了__call__,所以t实例能被调用

__call__ is called, fowhich would return 1



1

for e in TestIter():#因为实现了__iter__方法，所以t能被迭代。
    print(e)

__iter__ is called!
1
2
3
4
5
6

object() - 所有类的基类

base = object()
type(base)

object

open() - 打开文件

描述：
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:
f = open('d:/a.txt', mode='r', encoding='utf-8')
f.read()

mode取值表：

字符 意义
‘r’ ' 读取（默认）
'w' 写入，并先截断文件
'x' 排它性创建，如果文件已存在则失败
'a' 写入，如果文件存在则在末尾追加
'b' 二进制模式
't' 文本模式（默认）
'+' 打开用于更新（读取与写入）

pow() - 次幂

pow(base, exp, mod)，base为底的exp次幂，如果mod给出，取余！

pow(3, 2, 4)

1

print() - 打印

ls = [1,2,3]
print(ls)

[1, 2, 3]

print(f'ls:{ls}')

ls:[1, 2, 3]

print('ls:{}'.format(ls))

ls:[1, 2, 3]

print('ls:', ls)

ls: [1, 2, 3]

property() - 创建属性

返回 property 属性，典型用法：

class C:
    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
    
    #使用property来创建 property 属性
    x = property(getx, setx, delx, "I'm the 'x' property.")

使用python装饰器，实现与上完全一样的效果代码：

class C:
    def __init__(self):
        self._x = None
        
    @property
    def x(self):
        return self._x
    
    @x.setter
    def x(self, value):
        self._x = value
        
    @x.deleter
    def x(self):
        del self._x

range() - 创建序列

两种用法：

  1. range(stop);

  2. range(start, stop[,step])

生成一个不可变序列。

range(8)

range(0, 8)

range(2,10,2)

range(2, 10, 2)

list(range(2, 10, 2))

[2, 4, 6, 8]

reversed() - 反向迭代

rev = reversed([1, 4, 2, 3, 1])
for i in rev:
    print(i)

1
3
2
4
1

round() - 四舍五入

round(x[, n])，四舍五入，n代表小数点后保留几位。

round(42342.4563242, 3)

42342.456

round(2.04, 1)

2.0

round(2.05, 1)

2.0

set() - 转为集合类型

描述：
set()函数创建一个无序不重复的元素及，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

语法：
class set([iterable])

参数：

  • iterable --可迭代对象

返回值：
新的集合对象。

a = [1, 2, 3, 4, 1, 2]
set(a)

{1, 2, 3, 4}

x = set('hello world')
y = set('python')
x,y

({' ', 'd', 'e', 'h', 'l', 'o', 'r', 'w'}, {'h', 'n', 'o', 'p', 't', 'y'})

x & y

{'h', 'o'}

x | y

{' ', 'd', 'e', 'h', 'l', 'n', 'o', 'p', 'r', 't', 'w', 'y'}

x - y

{' ', 'd', 'e', 'l', 'r', 'w'}

slice() - 转为切片对象

描述：
slice()函数主要用在切片操作函数里的参数传递。

语法：
class slice(stop)

class slice(start, stop[, step])

参数：

  • start -- 其实位置
  • stop -- 结束位置
  • step -- 间距

返回值：
返回一个切边对象

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
my_slice_meaning = slice(0, 11, 2)
a[my_slice_meaning]

[1, 3, 5, 7, 9, 11]

my_slice = slice(5) #设置截取5个元素的切片
my_slice

slice(None, 5, None)

b = range(10)
b[my_slice]

range(0, 5)

sorted() - 排序函数

描述：
sorted()函数对所有迭代的对象进行排序操作。

sort 与 sorted 的区别：

  • sort是应用在 list 上的方法，返回的是对已经存在的列表进行操作。
  • sorted 可以对所有可迭代对象进行排序操作。返回的是一个新的list，而不是在园的的基础上进行的操作。

语法：
sorted(iterable, key=None, reverse=False)

参数：

  • iterable -- 可迭代对象
  • key -- 主要用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  • reverse -- 排序规则，reverse=True降序，reverse=False升序(默认)。

返回值：
返回重新排序的列表，是新的列表，不是原列表。

a = [1, 5, 2, 4, 3]
sorted(a)

[1, 2, 3, 4, 5]

a

[1, 5, 2, 4, 3]

sorted({'a': 5, 'b': 3, 'c': 1, 'd': 2, 'e': 4})

['a', 'b', 'c', 'd', 'e']

a = [{'name':'dafei', 'age':19, 'gender':'male'}, 
     {'name':'xiaohua', 'age':18, 'gender':'female'}]
sorted(a, key=lambda x: x['age'], reverse=False)

[{'name': 'xiaohua', 'age': 18, 'gender': 'female'},
 {'name': 'dafei', 'age': 19, 'gender': 'male'}]

b = [5, 9, 3, 6, 2, 7]
c = sorted(b, key=lambda x: x*(-1))
c

[9, 7, 6, 5, 3, 2]

sum() - 求和函数

sum(iterable[, start]),

  • iterable -- 可迭代对象,如列表、元组、集合。
  • start -- 指定相加的参数，如果没有设置这个值，默认为0
sum([1, 3, 5]),sum([1, 3, 5], 10)

(9, 19)

sum((2, 1, 5), 2)

10

sum({2, 4, 6}, 10)

22

tuple() - 转元组

tuple()将对象转为一个不可变的类型类型元组。

ls = [1, 3, 5]
tp = tuple(ls)
tp

(1, 3, 5)

type() - 查看对象类型

描述：
type()函数如果只有第一个参数object则返回对象的类型，三个参数则返回新的类型的对象。

isinstance() 与 type() 区别：

  • type()不会认为子类时一种父类类型，不考虑继承关系。
  • isinstance()会认为子类是一种父类类型，考虑继承关系。

语法：

  • type(object)
  • type(name, bases, dict)

参数：

  • name -- 类的名称。
  • bases -- 基类的元组。
  • dict -- 字典，类内定义的命名空间变量。

返回值：
一个参数返回对象类型；
三个参数返回新的类型对象。

type(1),type('dafei'), type((1, 2))

(int, str, tuple)

class X(object):
    a = 1

X = type('X', (object,),  dict(a=1))    #产生一个新的类型 X
X

__main__.X

class Student():
    def __init__(self, id, name):
        self.id = id
        self.name = name
        
    def __repr__(self):
        return  'id = '+self.id +', name = '+self.name
    
dafei = Student(id='01', name='dafei')
type(dafei)

__main__.Student

zip() - 聚合迭代器

创建一个聚合了来自每个迭代器对象中的元素的迭代器。

x = [3, 2, 1]
y = [4, 5, 6]
list(zip(x, y))

[(3, 4), (2, 5), (1, 6)]

a = range(5)
b = list('zhangfei')
list(zip(a,b))

[(0, 'z'), (1, 'h'), (2, 'a'), (3, 'n'), (4, 'g')]

[str(y) + str(x) for x, y in zip(a, b)]

['z0', 'h1', 'a2', 'n3', 'g4']

nonlocal - 声明变量用于内嵌函数中

关键字 nonlocal 常用于函数嵌套中，声明变量i为非局部变量；如果不声明，i+=1表明i为函数wrapper内的局部变量，因为在i+=1引用（reference）时，i未被声明，所以会报unreferenced variable的错误。

def excepter(f):
    i = 0
    t1 = time.time()
    def wrapper():
        try:
            f()
        except Exception as e:
            nonlocal i
            i += 1
            print(f'e.args[0]: {i}')
            t2 = time.time()
            if i == n:
                print(f'spending time:{round(t2-t1,2)}')
    return wrapper

global - 声明为全局变量

为什么要有global,一个变量被多个函数引用，想让全部变量被所有函数共享，直接用的写法：

i = 9
def pr():
    print(i)
def pa():
    print(i)
    pass
pr()
pa()
    

9
9

pr()和pa()两个函数都能共享变量i，程序没有报错，所以不明白为什么要用global。但如果出现一个函数使用i递增，如下：

def h():
    i += 1

h()

---------------------------------------------------------------------------

UnboundLocalError                         Traceback (most recent call last)

<ipython-input-64-30315b1bdaea> in <module>
      2     i += 1
      3 
----> 4 h()


<ipython-input-64-30315b1bdaea> in h()
      1 def h():
----> 2     i += 1
      3 
      4 h()


UnboundLocalError: local variable 'i' referenced before assignment

这时出错了，抛出UnboundLocalError异常:local variable 'i' referenced before assignment（局部变量未定义），原来编译器在解释i+=1时会把i解析为函数h()内的局部变量，很显然在函数内，编译器找不到对变量i的定义，所以报错。

global就是为解决此问题而被剔除，在函数h内，显式地告诉编译器i为全局变量，然后编译器会在函数外面寻找i的定义，执行完i+=1后，i还为全部变量，值加1：

i = 3
def h():
    global i
    i += 1

h()
print(i)
h()
print(i)

4
5
posted @ 2020-09-29 13:40  zhangfei2020  阅读(258)  评论(0)    收藏  举报