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