python_函数&模块&包

一.函数

1.无参无返回值

#实例
def test():
    """
    这是一个无参数无返回值的函数
    打印一个helloworld
    :return: None
    """
	print("hello world")
test()

#打印结果
hello world

附加：查看函数的属性，获取方法文档说明

#实例
def test():
    """
    这是一个无参数无返回值的函数
    打印一个helloworld
    :return: None
    """
    print("hello world")
test()
print(test.__doc__)

#打印结果
hello world

    这是一个无参数无返回值的函数
    打印一个helloworld
    :return: None

2.有参无返回值

#实例
def add(a, b):
    """
    有参数无返回值的方法
    :param a:
    :param b:
    :return:None
    """
    c = a + b
    print(c)
add(2,3)

#打印结果
5

3.有参数有返回值

#实例1
def add(a,b):
    c=a+b
    return c
i=add(2,3)
print(i)

#打印结果
5

#实例2
def add1(a,b):
    s=a+b
    d=a/b
    return s,d
s,d=add1(2,3)
print(s,d)

#打印结果
5 0.6666666666666666

4.值传递与引用传递*

(1).值传递

​ 即：不可变对象的传递。python中传递字符串、数字、元组时，当成值传递方式传递。是将当前变量复制了一份，将副本传递过去。修改的是副本，对原件没有影响。

#举例实例（类似于）
a=3
def test(a):
    a=5
    print(a)
test(a)
print(a)

#打印结果
5
3

#解释：
#方法里边将复制的3改成5，里边打印5；方法外边依然是3。

(2).引用传递

​ 即：可变对象传递。python中传递字典、列表时，当成可变对象传递，传自身。

#举例实例1（类似于）
def test (a):
    a.append(3)
    print(a)
a=[1,2,3]
test(a)
print(a)

#打印结果
[1, 2, 3, 3]
[1, 2, 3, 3]

#举例实例2（类似于）
def test(a):
    a["a"]=3
    print(a)
a={}
a["b"]=4
test(a)
print(a)

#打印结果
{'b': 4, 'a': 3}
{'b': 4, 'a': 3}

5.建议变量，返回值类型*

原文链接： https://www.cnblogs.com/linkenpark/p/11676297.html

#实例
#3.5版本以后加的内容。**建议**
#动态语言不能指定类型。做法如下：
#参数：当制定了参数类型是，在调用参数时，会提示数据类型，如图1所示。
#返回值：指定返回值类型，如图2所示。
def test(a:int, b:str) -> str:
    print(a, b)
    return 1000

if __name__ == '__main__':
    test('test', 'abc')

#解释：
函数test，
a:int  指定了输入参数a为int类型，
b:str  b为str类型，
-> str  返回值为srt类型。

可以看到，
在方法中，我们最终返回了一个int，此时pycharm就会有警告；
当我们在调用这个方法时，参数a我们输入的是字符串，此时也会有警告；
但非常重要的一点是，pycharm只是提出了警告，但实际上运行是不会报错，毕竟python的本质还是动态语言

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yfI8JP6w-1573221794007)(C:\Users\Administrator\Desktop\1.png)]

图1

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DH7AMUPM-1573221794009)(C:\Users\Administrator\Desktop\2.png)]

图2

6.必须参数

#实例
def showinfo(name):
    print("名字是：{}".format(name))
showinfo("张三")

#打印结果
名字是：张三

7.关键字参数

#实例
def showinfo(name,age):
    print("名字是：{}，年龄是：{}".format(name,age))
showinfo(name="李四",age=50)

#打印结果
名字是：李四，年龄是：50

8.默认参数

#实例
def showinfo(name,age=30):
    print("名字是：{}，年龄是：{}".format(name,age))
showinfo("张三",50)

#打印结果
名字是：张三，年龄是：50

9.不定长参数*

第一种：加了*的参数

​ 不传参也行，传一个参数也行，传多个参数也行。

#实例1:加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
#!/usr/bin/python3
  
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )

#打印结果
输出: 
70
(60, 50)

#实例2:如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。
#!/usr/bin/python3
 
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   for var in vartuple:
      print (var)
   return
 
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )

#打印结果
输出:
10
输出:
70
60
50

附加：序列解包

传多个参数时，传入的是元组。当需要打印每个元素时，则需要序列解包。

#序列解包前
def showinfo(*a):
    """
    不定长参数 （变参)
    :param a:
    :return:
    """
    print(a)
showinfo(1,2,3)

#打印结果
(1, 2, 3)

#序列解包后
def showinfo(*a):
    """
    不定长参数 （变参)
    :param a:
    :return:
    """
    print(*a)
showinfo(1,2,3)

#打印结果
1 2 3

第二种：加了**的参数

#实例
def register(name,password,**kwarges):
    if kwarges:
        print(name,password,kwarges)
    else:
        print(name,password)
register("王麻子","123456",age=20,height="30米",birth="1995-04-20",sex="male")
register("王麻子","123456")

#打印结果
王麻子 123456 {'age': 20, 'height': '30米', 'birth': '1995-04-20', 'sex': 'male'}
王麻子 123456

第三种：单独*

#实例：如果单独出现星号 * 后的参数必须用关键字传入。
>>> def f(a,b,*,c):
...     return a+b+c
... 
>>> f(1,2,3)   # 报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() takes 2 positional arguments but 3 were given
>>> f(1,2,c=3) # 正常
6

10.匿名函数

lambda x y:x+y

• lambda:关键字，是函数。将该函数赋给变量，就可以调用。
• 匿名的目的就是要没有名字，给匿名函数赋给一个名字是没有意义的
• 匿名函数的参数规则、作用域关系与有名函数是一样的
• 匿名函数的函数体通常应该是 一个表达式,该表达式必须要有一个返回值

#实例
a = lambda x : x**2
print(a(3))

#打印结果
9

11.动态方法传递*

#实例1
a=lambda :print("hello world")
def method(fn):
    fn()
method(a)

#打印结果
hello world

#实例2
def method(fn):
    """
    动态方法传递
    :param fn:
    :return:
    """
    fn()

method(lambda:print("hello"))

#打印结果
hello

12.递归：方法调自身*

#实例
def fn(x):
    if x == 1 or x == 2:
        return x
    else:
        return fn(x-1)+fn(x-2)

print(fn(5))

#打印结果
8

13.在python中任何方法都有返回值

#实例
def test():
    print("ehllooo")
    # return None
print(test())

#打印结果
ehllooo
None

14.作用域*

​ 变量作用域只有在方法内和模块里才有定义，初次之外，在任何地方都可以访问，例子如下for循环：

#实例
for i in range(4):
    print(i)
print(i)

#打印结果
0
1
2
3
3

(1).局部作用域

#实例
def method():
    """
    内部局部变量外部不可以访问
    :return:
    """
    num = 23
    print(num)

method()

#打印结果
23

(2).闭包作用域

​ 方法中定义方法。通过外部方法访问内部方法。

#实例1
def outside():
    name="张三"
    def inside():
        print("内部方法")
    inside()
    print(name)
outside()

#打印结果
内部方法
张三

#实例2
def outside():
    name="张三"
    def inside():
        print("内部方法")
    return inside()
    print(name)
outside()

#打印结果
内部方法

#实例3
def outside():
    name="张三"
    def inside():
        print("内部方法")
        return "这是内部方法"
    print(name)
    return inside()
a=outside()
print(a)
a=(a)
print(a)

#打印结果
张三
内部方法
这是内部方法
这是内部方法

(3).全局作用域

#实例
name01 = '1'
name02 = '1'
def test(name,name02): #因为函数内的name01被golbal成了全局变量，所有此时的函数参数name不能写成name01
    global name01
    name01 = '2'
    name02 = '2'

test(name01, name02)
print(name01, name02)#2 1 #函数内的name01被声明成了全局变量，所以函数内的name01可以修改函数外部name01的值

#列表、字典、集合、类是可以直接在局部变量里面修改的
#字符串、整数是不可以直接在局部变量里面修改的
name03 = 1
name04 = ['a','b','c']
def test2(name,name02): #因为函数内的name01被golbal成了全局变量，所有此时的函数参数name不能写成name01
    name03 = 2
    name04[0] = 'd'
test2(name03, name04)
print(name03) #1 #整数是不可以直接在局部变量里面修改的
print(name04) #['d', 'b', 'c'] #列表、字典、集合、类是可以直接在局部变量里面修改的

#打印结果
2 1
1
['d', 'b', 'c']

​ 局部、闭包、全局的查找规则：局部->闭包->全局->内建的查找过程。

(4).内建作用域

​ 系统自身定义的变量。用的很少。

#实例
print(int(32))

#打印结果
32

附加：

#实例1
def action():
    a = []
    for i in range(5):
        a.append(lambda n: i ** n)
    return a

a = action()
print(a[0](2))#[0]当调时候，for循环已经结束，此时i=4
print(a[2](2))#[2]当调时候，for循环已经结束，此时i=4
print(a[3](2))#[3]当调时候，for循环已经结束，此时i=4
print(a[0])

#打印结果
16
16
16
<function action.<locals>.<lambda> at 0x0000026140FD0510>

#实例2
def action():
    a = []
    for i in range(5):
        a.append(lambda n,i=i : i ** n)#i=i:默认参数
    return a

a = action()
print(a[0](2,2))#传参
print(a[0](2))
print(a[2](2))
print(a[3](2))
print(a[0])

#打印结果
4
0
4
9
<function action.<locals>.<lambda> at 0x000002613D1312F0>

15.生成器*

#实例1：生成器原理
num =(i for i in range(10))
print(num)
print(next(num))
print(next(num))
print(next(num))

#打印结果
0
1
2

#实例2：不使用生成器会增加内存
def get_num(numlist):
    print(numlist)

numlist=list(range(10))
get_num(numlist)

#打印结果
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

#实例3：使用函数制作生成器
def get_num(numlist):
    for e in numlist:
        yield e
numlist=list(range(10))
num=get_num(numlist)
print(next(num))
print(next(num))
print(next(num))
print(next(num))

#打印结果
0
1
2
3

二.模块

1.import

import os
import sys
print(sys.version)
print(os.name)
print(sys.path)

#打印结果
3.7.3 (default, Mar 27 2019, 17:13:21) [MSC v.1915 64 bit (AMD64)]
nt
['D:\\AI_clb\\code\\20191017_python函数模块包', 'D:\\AI_clb\\code\\20191017_python函数模块包', 'C:\\Users\\Administrator\\Anaconda3\\python37.zip', 'C:\\Users\\Administrator\\Anaconda3\\DLLs', 'C:\\Users\\Administrator\\Anaconda3\\lib', 'C:\\Users\\Administrator\\Anaconda3', 'C:\\Users\\Administrator\\Anaconda3\\lib\\site-packages', 'C:\\Users\\Administrator\\Anaconda3\\lib\\site-packages\\win32', 'C:\\Users\\Administrator\\Anaconda3\\lib\\site-packages\\win32\\lib', 'C:\\Users\\Administrator\\Anaconda3\\lib\\site-packages\\Pythonwin']

2.if __name _____ == ‘__main ___’

原文链接： https://www.cnblogs.com/chenhuabin/p/10118199.html

3._____init____.py

原文链接： https://www.cnblogs.com/tp1226/p/8453854.html

三.计算MNIST数据集中每个标签的个数

1.思路：

​ 使用字典做。因为字典中的键不可重复。例如：当1作为键，凡是1的数据都可以归纳到1这个键的字典中，值为个数。

2.准备工作：

（1）item()

#实例
person = {'name': 'lizhong', 'age': '26', 'city': 'BeiJing', 'blog': 'www.jb51.net'}
for x in person.items():
    print(x)

#打印结果
('name', 'lizhong')
('age', '26')
('city', 'BeiJing')
('blog', 'www.jb51.net')

（2）get()

#实例
dict = {'Name': 'Zara', 'Age': 27}

print("Value : %s" %  dict.get('Age'))
print( "Value : %s" %  dict.get('Sex', "Never"))

#打印结果
Value : 27
Value : Never

3.实现：

#实例
import torchvision as tv
dataset=tv.datasets.MNIST(root="datasets/",train=True,download=True)
print(dataset.targets.shape)
def statistics():
    data=dataset.targets
    print(data[0])
    nums={}
    for i in data:
        if nums.get(i.item()):
            nums[i.item()]+=1
        else:
            nums[i.item()]=1
    print(nums)
statistics()

#打印结果
torch.Size([60000])
tensor(5)
{5: 5421, 0: 5923, 4: 5842, 1: 6742, 9: 5949, 2: 5958, 3: 6131, 6: 5918, 7: 6265, 8: 5851}