Python_基础_(局部全局变量，函数各类类型)

一，局部变量，全局变量

 1.无global 关键字：当函数中无关键字 global 时，当局部变量与全局变量命名相同，优先读取函数中的变量，函数中没法对全局变量进行修改，但当全局变量的类型为列表时，可对内部的元素进行操做（例：test.append）。

li = ["1",2,3,4,5] def test(): li.append("hello")    # 对原有的列表进行操做
    # print(li)
 test() print(li) # 输出 ['1', 2, 3, 4, 5, 'hello']

 

2.有global关键字

name = "aaaa"
def test(): global name name = "bbbb" test() print(name) # 输出 bbbb

 

# 注：

# 下方的程序会产生报错，在一个函数中既有局部变量，有引用了全局变量（在函数中声明引用全局变量，应将global放于最上方）
 name = "aaaa"
def test(): name = "cccc"
    global name name = "bbbb" test() print(name) # 报错
  File "F:/Python_Project/Test/Test.py", line 242
    global name ^ SyntaxError: name 'name' is assigned to before global declaration

 

## 书写规格 ##

######### 全局变量变量名大写
######### 局部变量变量名小写

 二，函数做用域

 

# 当一个函数中返回另外一个函数的函数名，其实际返回的是该函数的地址，能够直接使用该地址调用该函数

def test1(): print("this is test1()") def test2(): print("this is test2()") return test1    # 返回函数test1()的地址
 res = test2() print(res) res() # 当执行函数test2()时，返回了函数test1()的地址，因此res()代指为函数test1()

# 执行的结果
this is test2() <function test1 at 0x00000197E46BC378> this is test1()

 

def one(): print("this is one") def two(): print("this is two") def three(): print("this is three") return three return two test_two = one()    # 执行函数one() 返回函数two()的地址
test_three = test_two() # 执行函数two() 返回函数three的地址
test_three()    # 执行函数three)


# 注：上面的三步至关于 one()()()

# 输出结果
this is one this is two this is three

三，函数嵌套

# nonlocal 指定上一级变量（name 为函数test1()中的name）
name = "hello"
def test1(): name = "world"
    def test2(): nonlocal name print(name)

 四，递归

 编程语言中的定义：函数直接或间接的调用函数自己，则该函数称为递归函数

再数学中的定义：对于某一函数F(x)，其定义域是集合A，那么若对于A集合中的某一个值X0，其函数值F(x0)由F(F(x0))决定，那么就称F(x)为递归函数

## 如下为一个递归，该递归为一个死循环

def clac(n): print(n) clac(n): clac(10)

 

 

# 递归所具备的特性

1.函数的递归必须有一个明确的结束条件

2.每次进入更深的一层递归时，问题的规模应当比上次递归有所减小

def test(n): print(n) if int(n/2) == 0: return n return test(int(n/2)) test(10) # 输出
10
5
2
1

 

 

五，匿名函数　　关键字lambda

# 匿名函数
lambda x:x+1    # x：函数的形参 x+1：为函数的返回值

# 上方匿名函数对应的普通函数
def calc(x): return x+1 func = lambda x:x+1
print(func(10))    # 至关于执行匿名函数


lambda x,y,z:(x+1,y+1,z+1)    # 在lambda中返回多个值 得加上括号

 

 六，编程方法论

 1.面向过程：

　　面向过程就是分析出解决问题所须要的步骤，而后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就能够了。

面向过程实际上是最为实际的一种思考方式，就算是 面向对象的方法也是含有面向过程的思想。能够说面向过程是一种基础的方法。它考虑的是实际地实现。通常的面向过程是从上往下步步求精，因此面向过程最重要的是模块化的思想方法。对比面向过程，面向对象的方法主要是把事物给对象化，对象包括属性与行为。当程序规模不是很大时，面向过程的方法还会体现出一种优点。由于程序的流程很清楚，按着模块与函数的方法能够很好的组织。好比拿学生早上起来这件事说明面向过程，粗略的能够将过程拟为：

(1)起床

(2)穿衣

(3)洗脸刷牙

(4)去学校

而这4步就是一步一步地完成，它的顺序很重要，你只须要一个一个地实现就好了。而若是是用面向对象的方法的话，可能就只抽象出一个学生的类，它包括这四个方法，可是具体的顺序就不必定按照原来的顺序。

https://baike.baidu.com/item/%E9%9D%A2%E5%90%91%E8%BF%87%E7%A8%8B/9957246?fr=aladdin

2.面向对象：

　　向对象是一种对现实世界理解和抽象的方法...待补充

3.函数式编程：

　　待补充

七，内置函数

 ### map()函数

## 第一种例子
num_l = [1,2,3,4,5] def add_one(x): x = x + 1
    return x def map_test(func,array): ret = [] for i in array: res = func(i)   # 调用函数add_one() 后返回计算后的值
        ret.append(res) # 将获得的值追加到列表ret中
    return ret print(map_test(add_one,num_l))  # 传入执行自加一的函数 传入源列表

# 结果 [2, 3, 4, 5, 6]

## 第二种写法 利用抽象函数
num_l = [1,2,3,4,5] def map_test(func,array): ret = [] for i in array: res = func(i)  # 利用抽象函数进行计算
        ret.append(res) # 将获得的值追加到列表ret中
    return ret print(map_test(lambda x:x+1,num_l))  # 利用抽象函数 传入源列表
print(map_test(lambda x:x-1,num_l)) # 结果
[2, 3, 4, 5, 6] [0, 1, 2, 3, 4] ## 第三种写法 利用map函数
 num_l = [1,2,3,4,5] res = map(lambda x:x+1,num_l) print(list(res)) ### 在python3.5中此时获得的是一个可迭代对象 <map object at 0x000001EA24F68240> ### 在python2.7中直接获得的是一个列表[2, 3, 4, 5, 6, 7, 8]

# 将一个字符串转成大写形式，列表
msg = "helloworld"
print(list(map(lambda x:x.upper(),msg))) # 输出['H', 'E', 'L', 'L', 'O', 'W', 'O', 'R', 'L', 'D']

### filter()函数

## 过滤掉末尾以 sb 结尾的字符串

### 第一种写法
name = ['aaaa_sb','bbbb_sb','cccc_sb','dddd'] def end_filter(n): return n.endswith("sb") def filter_test(func,array): res = [] for p in array: if not func(p): res.append(p) return res print(filter_test(end_filter,name)) # 输出['bbbb']


### 第二种写法
name = ['aaaa_sb','bbbb_sb','cccc_sb','dddd'] def filter_test(func,array): res = [] for p in array: if not func(p): res.append(p) return res print(filter_test(lambda x:x.endswith("sb"),name)) # 输出['bbbb']

### 第三种写法 利用filter函数
name = ['aaaa_sb','bbbb_sb','cccc_sb','dddd'] print(list(filter(lambda x:not x.endswith('sb'),name))) # 输出['bbbb']

### reduce

# 在Python2种能够直接使用该函数
# 咋Python3种得导入该模块
from functools import reduce(重模块functools种导入函数reduce )

### 第一种写法

from functools import reduce num_list = [1,2,3,4,5] def reduce_test(func,array): res = array.pop(0) for num in array: res = func(res,num) return res print(reduce_test(lambda x,y:x+y,num_list)) print(reduce_test(lambda x,y:x*y,num_list)) ### 第二种写法 利用reduce函数
print(reduce(lambda x,y:x+y,num_list)) print(reduce(lambda x,y:x*y,num_list))

总结：

map：对原有的数据进行加工，处理列表中的每一个元素，获得的结果是一个“列表”（迭代器的形式），该列表的个数及位置与原来同样
filter：对数据进行过滤（遍历序列中的每一个元素，判断每一个元素获得布尔值，若是为True则留下来）
reduce：对原有的数据进行压缩(相加 相乘)

其它内置函数：

abs()   # 取绝对值
 all() # 对序列中的元素进行布尔运算（0，None，空字符串为假），序列中的元素一个为假 则为假
 any() # 序列中的元素有一个为真 则为真
 bool() # 判断布尔值（0，None，空字符串 为False）其他的为True
 hex() # 十进制转十六进制
 oct() # 十进制转八进制
 bin() # 将十进制转为二进制
 bytes() # 将一个字符串转成字节的形式
name = "你好中国" ret = bytes(name,encoding="utf-8") print(bytes(ret) # 得指定编码方式 # 输出的结果为 '\xe4\xbd\xa0\xe5\xa5\xbd\xe4\xb8\xad\xe5\x9b\xbd'

print(ret.decode("UTF-8")) # 进行解码（注何种编码格式编码,就用各类编码格式解码） # 输出的结果为 你好中国
 chr() # 按照ASCII码变进行对应的转换
ord(97) # 显示在ASCII码中对应的字符
 dir() # 打印某个对象中全部的方法 例如dir(all)
 divmod() # divmod(10,3) 输出的结果为(3,1),输出商和余数
 eval() # 功能一 # 将字符串中的数据结构提取出来
dic = {"name": "henry"}  # 定义一个字典
dic_str = str(dic)  # 将其转换成字符串的形式
print(dic_str) d = eval(dic_str)  # 将字符串中的字典提取出来
print(d["name"]) # 功能二：将字符串中的表达式进行算术运算
num_list = "1+2+3-4*5/6"
print(eval(num_list)) hash() # 可hash的数据类型为不可变数据类型，不可hash的数据便可变的数据类型 # 无论所给的字符串有多长，相同数据获得的哈希数相同(注意每次运行都会获得一个新的值) # 不能根据获得的哈希值进行反推获得原来的字符串 # hash能够用来判断文件或数据有没有被修改过
name = "你好中国"
print(hash(name)) # 7099912592138176852
 help() # 用于打印一个方法的具体使用方法help(all)

print(isinstance(1, int))       # 判断1是不是int型,返回布尔值
print(isinstance('abc', str))   # 判断abc是不是str型
print(isinstance([], list))     # 判断是否为列表类型
print(isinstance({}, dict))     # 判断是否为字典类型
 globals() # 打印全局的全部变量
locals()    # 打印局部变量
 num_list = [1, 2, 3, 4] min(num_list) # 取列表最大值
max(num_list)   # 取列表最小值（传入的数据类型是一个可迭代类型） # 1.max函数处理的是可迭代的对象，至关于一个for循环取出每一个元素进行比较。注意：不一样类型元素之间不能进行比较 # 2.每一个元素间进行比较，是从每一个元素的第一个位置一次比较，若是这个位置分出大小后，后面的则不须要进行比肩
 dic = {"name": "hh", "age", 18} max(dic) # 比较的是key
max(dic.values())   # 比较的是value 没法获得与Key相对应



# zip(a序列,b序列) a序列与b序列为一一对应的关系 # 序列包括 列表 元组 字符串 # 元组
print(list(zip(("a", "b", "c"), (1, 2, 3))))  # 输出的为 [("a",1),("b",2),("c",3)]
print(list(zip(("a", "b", "c"), (1, 2, 3, 4))))  # 输出也为[("a",1),("b",2),("c",3)]
print(list(zip(("a", "b", "c", "d"), (1, 2, 3))))  # 输出也为[("a",1),("b",2),("c",3)]

# 字符串
print(zip("hello", "12345")) # [('h', '1'), ('e', '2'), ('l', '3'), ('l', '4'), ('o', '5')]

print(zip(["h", "e", "l", "l", "o"], ["1", "2", "3", "4", "5"])) # [('h', '1'), ('e', '3'), ('l', '2'), ('o', '5')]
 p = {"name": "henry", "age": 18} print(list(zip(p.keys(), p.values()))) # [("name","henry"),("age",18)]

# zip和max配合使用_初级玩法 # 取出一个字典中最大的年纪
>> > age_dic = {'a_age': 18, 'b_age': 30, 'c_age': 10} >> > print(max(zip(age_dic.values(), age_dic.keys()))) # 先用zip将其转为元组模式 在进行比较
(30, 'b_age') >> > num_list = ["a1", "a2", "a3", 100] print(max(num_list))  # 会报错 不一样的数据类型间不能比较

# zip和max配合使_终极玩法
people = [ {"name": "aaa", "age": 19} {"name": "bbb", "age": 13} {"name": "ccc", "age": 12} {"name": "ddd", "age": 11} ] max(people) # 直接报错（字典自己无序，多个字典间不能进行比较）
print(max(people, value=lambda dic: dic['age'])) pow(2, 2)  # 至关于求2**2
pow(3, 2, 2)  # 至关于32次方，对2取余 3**2%2
 recursed() # 将一个序列反转（对源序列无影响）
 round(2.4)  # 四舍五入
 set() # 将其转为集合形式
print(set("hello")) set(['h', 'e', 'l', 'o']) num_list = "hello" s = slice(3, 5)      # 切片
s1 = slice(3, 5,2)  # 定义切片步长
 a = [3, 4, 5, 3, 3, 2, 6] print(sorted(a))   # 对序列进行排序，实质就是进行比较大小，不一样类型的数据元素之间不能进行排序
 people = [ {"name": "aaa", "age": 19}, {"name": "bbb", "age": 13}, {"name": "ccc", "age": 12}, {"name": "ddd", "age": 11} ] print(sorted(people, key=lambda dic: dic['age']))  # 对字典的集合进行排序 # [{'name': 'ddd', 'age': 11}, {'name': 'ccc', 'age': 12}, {'name': 'bbb', 'age': 13}, {'name': 'aaa', 'age': 19}]
 name_dic = { "python": 1, "java": 2, "C": 3 } print(sorted(name_dic, key=lambda key: name_dic[key])) # ['python', 'java', 'C']
 a = [1, 2, 3, 5] sum(a) # 求和
 type(a) # 查看数据类型 # 根据type判断数据类型 根据不一样的数据类型执行不一样的逻辑
 vars() # 当vars没有参数时，与locas() 的用法相同，打印局部变量
vars(int)   # 当有参数时，查看某个对象中的全部方法，以字典的形式显示

其它内置函数