Python

TIP

最后更新时间:2019年8月15日

字数:20478

参考资料

认识Python

  • Python是著名的“龟叔”Guido van Rossum在1989年圣诞节期间,为了打发无聊的圣诞节而编写的一个编程语言
  • Python是一种动态的、面向对象的脚本语言,最初被设计用于编写自动化脚本(shell),随着版本的不断更新和语言新功能的添加,越来越多被用于独立的、大型项目的开发

Python2 or Python3

TIP

py2.7是2.x系列的最后一个版本,已经停止开发,不再增加新功能2020年终止支持。所有的最新的标准库的更新改进,只会在3.x的版本里出现。Guido决定清理Python2.x ,并且不再兼容旧版本。最大的一个改变就是使用Unicode作为默认编码。Pyhton2.x中直接写中文会报错,Python3中可以直接写中文了。从开源项目看,支持py3的比例已经大大提高,知名的项目一般都支持py2.7和py3+。py3比py2更规范统一、去掉了没必要的关键字Python3.x还在持续改进。

如果没有特殊的项目需求,为了Python的发展我们更应该选择Python3!

应用领域

  • Web 和 Internet开发
  • 科学计算和统计
  • 教育
  • 桌面界面开发
  • 软件开发
  • 后端开发

开发环境

推荐PyCharm + anaconda

Python解释器

当我们编写Python代码时,我们得到的是一个包含Python代码的以.py为扩展名的文本文件。要运行代码,就需要Python解释器去执行.py文件

常见Python解释器

  • 官方解释器:CPython
    • 最广泛的解释器
    • C语言编写
  • IPython
    • 一个交互式、功能增强的CPython
  • PyPy
    • Python语言编写的Python解释器,JIT技术,动态编译Python代码
    • JIP:just in time 动态优化
  • Jython
    • Python的源代码编译成java的字节码,跑在JVM上
  • IronPython
    • 与Jython类似,运行在.net平台上的解释器,Python代码呗编译成.net字节码

py文件和pyc文件

  • 在Python的程序中,是把原始程序代码放在.py文件里,而Python会在执行.py文件的时候,将.py形式的程序编译成中间式文件(byte-compiled)的.pyc文件,这么做的目的就是为了加快下次执行文件的速度。

  • 在我们运行python文件的时候,就会自动首先查看是否具有.pyc文件,如果有的话,而且.py文件的修改时间和.pyc的修改时间一样,就会读取.pyc文件,否则,Python就会读原来的.py文件。

  • 其实并不是所有的.py文件在与运行的时候都会产生.pyc文件,只有在import相应的.py文件的时候,才会生成相应的.pyc文件

基本语法

注释

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

# 我是单行注释

""" 
我
是
多
行
注
释
"""
1
2
3
4
5
6
7
8
9
10
11
12
13

变量

  • 变量其实就相当于我们数学中的未知数x,y,z等

变量命名规范

  • 变量命名可以包含数字,大小写字母,下划线或者更多
  • 不能以数字开头
  • 区分大小写(大小写敏感)
  • 以下划线开头的变量有特殊意义,不建议使用
  • 推荐使用驼峰命名法
  • 不能跟关键字和保留字重复

以下划线开头问题

特殊标识符:以下划线开头的标识符是有特殊含义的

  • 以单下划线开头 _foo 的代表不能直接访问的类属性,需通过类提供的接口进行访问,不能用 from xxx import * 而导入
  • 以双下划线开头的 _foo 代表类的私有成员_
  • _以双下划线开头和结尾的 _foo__ 代表 Python 里特殊方法专用的标识,如__init() 代表类的构造函数

常见保留字

[
    'and',
    'as',
    'assert',
    'break',
    'class',
    'continue',
    'def',
    'del',
    'elif', 
    'else',
    'except',
    'exec',
    'finally',
    'for',
    'from',
    'global',
    'if', 
    'import',
    'in',
    'is',
    'lambda',
    'not',
    'or',
    'pass',
    'print', 
    'raise',
    'return',
    'try',
    'while',
    'with',
    'yield'
]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

print函数

python print 函数用法总结

打印输出,print默认换行

  • 直接输出
  • 格式化输出(类似C语言)
# 直接输出
print('zhangsan')

# 格式化输出
age = 18
print('我叫:%s,我的年龄是:%d'%('张三',age)) # 我叫:张三,我的年龄是:18
1
2
3
4
5
6

格式化符号说明

符 号 描述
%c 格式化字符及其ASCII码
%s 格式化字符串
%d 格式化整数
%u 格式化无符号整型
%o 格式化无符号八进制数
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数(大写)
%f 格式化浮点数字,可指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同%e,用科学计数法格式化浮点数
%g %f和%e的简写
%G %f 和 %E 的简写
%p 用十六进制数格式化变量的地址

数据类型

  • Python有五种标准数据类型:

    • String:字符串
    • Numbers:数字
    • List:列表
    • Tuple:元组
    • Dictionary:字典
  • 集合类型:

    • 列表
    • 元组
    • 字典
  • 其余类型:

    • 布尔类型
    • 浮点数
    • 日期

TIP

数据类型也可以看做是一个”类“ 每一种数据类型都是一个对象,也具有其自己的属性和方法

type

可以使用type查看数据类型

# type(变量)

print(type('xx'))
print(type(1))
print(type([]))
print(type(('11', '22')))
print(type({}))
    
# 结果
<class 'str'>
<class 'int'>
<class 'list'>
<class 'tuple'>
<class 'dict'>
1
2
3
4
5
6
7
8
9
10
11
12
13
14

字符串(String)

字符串可以用单引号、双引号和三引号声明

# 变量被重写了
# 变量赋值用等号
name = "zhangsan"
name = "lisi"

print(name) # lisi

# 单引号和双引号都可以表示字符串
name1 = "zhangsan"
name2 = 'zhangsan'

print(name1) # zhangsan
print(name2) # zhangsan

# 外双内单
name3 = "hello 'name' world"
print(name3) # hello 'name' world

# 外单内双
name4 = 'hello "name" world'
print(name4) # hello "name" world

# 如果多个单的或者双的,是不允许的,必须使用转义符
name5 = "我是\"双引号\""
print(name5) # 我是"双引号"
name6 = '我是\'单引号\''
print(name6) # 我是'单引号'

# 三个引号:如果单引号和双引号都有,这个时候使用三引号就非常方便了,省略使用转移符的步骤
name7 = """It's "C",I have "A" and "B"。"""
print(name7) # It's "C",I have "A" and "B"。

# 可以同一行显示多条语句,方法是用分号 ; 分开
print(name6);print(name7) # 我是'单引号' 换行 It's "C",I have "A" and "B"。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

字符串操作

str = "xiao feng ge !"
print(type(str))#xiao feng ge !
print (str[0]) # x
print (str[1:3]) # ia 截取1-3 顾头不顾尾
print (str[:3]) # xia # 0-3
print (str[1:]) # iao feng ge ! 1到最后
print (str*3) # 输出三次 str :xiao feng ge !xiao feng ge !xiao feng ge !
print ('sys:'+str) # sys:xiao feng ge ! 字符串拼接
1
2
3
4
5
6
7
8

字符串格式化

  • 利用百分号(%)格式化
print("I am %s"%"xiaofengge") 
# I am xiaofengge

# 多个参数
print("I am %s , my age is %d" % ('xiaofengge',18)) 
# I am xiaofengge , my age is 18
1
2
3
4
5
6
  • format格式化
    • str.format()
    • 用{} 和 : 代替原来的 %
print("I am {0}".format('小峰哥')) 
# I am 小峰哥

print("I am {0} , my age is {1}".format('小峰哥',18)) 
# I am 小峰哥 , my age is 18
1
2
3
4
5

字符串转义

数字(Number)

数字类型属于不可改变的类型,如果改变数字类型,会被重新分配一个对象

  • 四种数字类型

    • 整型(int)
      • 32位系统上,整型是32位
      • 64位系统上,整型是64位
      • 小整数对象:小整数对象池,缓存
    • 长整型:long
      • 长整型不限制大小,但是实际情况是会做限制
    • 浮点型:float
      • 用来处理带有小数的数字
      • 类似于C语言中的double类型
    • 复数:complex
      • 复数是由实数部分和虚数部分组成
num1 = 888 # 赋值后Numbers对象就会被创建
num2 = 999

print('=====', num1,num2)
# 删除引用  删除后,就找不大这个变量了 后面也可以跟一个数组
del num1
# print num1 # NameError: name 'num1' is not defined 报错
print(num2)
1
2
3
4
5
6
7
8

列表(List)

Python中使用最频繁的数据类型,在其他编程语言中一般都叫做数组

列表特点:

  • 列表索引0开始
  • 访问[start] 返回一个元素
  • 访问[start,end] 返回一个数组,返回end之前的数据

列表方法

  • let(list)
  • max(list)
  • min(list)
  • cpm(list)
  • list() 转成list
  • list.append() 追加元素
  • list.count() 统计某个数据在列表中出现的次数
  • list.extent() 在列表末尾一次性追加多个数据,用于扩展原来的列表
  • list.index() 找到某个数据第一次出现的位置
  • list.insert(index,obj) 将对象插入到list中
    • index:要插入的位置
    • obj:要插入的对象
    • list.pop(index) 根据下标移除数组中的元素,并返回删除的值
      • index:默认 -1 (也就是最后一个元素)
    • list.remove() 移除列表中第一个匹配的值
    • list.reverse() 翻转列表
    • list.sort() 对list进行排序
list1 = ['111','222','333','444','555','666','777','888','999']
list2 = ['qqqq']
print('list1[0]:',list1[0]) # list1[0]: 111
print('list1[0:3]:',list1[0:3]) # list1[0:3]: ['111', '222', '333']
print('list1[:3]:',list1[:3]) # list1[:3]: ['111', '222', '333']
print('list1[3:]:',list1[3:]) # list1[3:]: ['444', '555', '666', '777', '888', '999']
print(list1 *3)# 输出三遍list1
print(list1 + list2) # 拼接输出,不是输出2个数组,结果是:['111', '222', '333', '444', '555', '666', '777', '888', '999', 'qqqq']

# 添加元素
list2.append('www') # append后面只允许跟一个参数
print(list2) # ['qqqq', 'www']
list2.append(['rrr','ttt']) # append后面只允许跟一个参数
print(list2) # 'qqqq', 'www', ['rrr', 'ttt']]

# 更新元素
list2[0] = 'aaa'
print(list2) # ['aaa', 'www', ['rrr', 'ttt']]

# 删除元素
del list2[2]
print(list2) # ['qqqq', 'www']

#len
print(len(list2)) # 列表元素个数1

# max min
print(max(list1)) # 999 返回列表元素最大值
print(min(list1)) # 111 返回列表元素最小值

# count
arr3 = ['a','b','a','b','a']
print(arr3.count('a')) # 3

# extend
arr3.extend(['d','e'])
print(arr3) # ['a', 'b', 'a', 'c', 'a', 'd', 'e']

# index
print(arr3.index('b')) # 1

# 删除元素
arr3.pop()
print(arr3) # ['a', 'b', 'a', 'b', 'a', 'd']
print(arr3.pop(0)) # a

# remove
print(arr3) # ['b', 'a', 'b', 'a', 'd']
# arr3.remove('a') # ['b', 'b', 'a', 'd']
arr3.reverse()
print(arr3) # ['d', 'a', 'b', 'a', 'b']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

元组(Tuple)

元组类似于list

元组特点:

  • 列表使用[],元组使用()

  • 元组的元素不允许修改,列表可以

列表和元组互相转换:

  • list:把元组转化为list
  • tuple:把list转化为元组

元组方法:

  • cmp(元组1,元组2) :比较2个元组是否一样

  • len() :查看元组个数

  • max() :元组中的最大值

  • min() :元组中的最小值

  • tuple() :将列表转换为元组

  • 访问元素:tuple[索引],和list列表一样

# 创建元组
tup1 = () # 空元组
tup2 = (1)
tup3 = (1,) # 元组只包含一个元素的时候,必须后面加上逗号,不然会被当做其余类型处理
tup4 = (1,'a',['b','c'])
print(tup2) # 1
print(type(tup1))# <type 'tuple'>
print(type(tup2))# <type 'int'>
print(type(tup3))# <type 'tuple'>

arr = ['a','b','c','d']
print(len(tup4))# 3
print(tuple(arr))# ('b', 'a', 'b', 'a', 'd') # 列表转元组
print(list(tup4))# [1, 'a', ['b', 'c']] # 元组转列表
1
2
3
4
5
6
7
8
9
10
11
12
13
14

字典(dictionary)

字典是我们常见的数据结构,也是python中基础的数据结构之一

字典特点:

  • 无需列表,和iOS中的字典一样
  • 通过key取值,有点类似于js中的对象
  • 字典通过大括号定义{},类似于json
  • 字典也被称为关联列表或者哈希表
  • key不允许重复,value必须是不可变的,如果键重复了,会被后面的覆盖掉
  • key因为是不可变的,可以是数字,字符串或者元组,但是列表不行
dict = {
  key1:value1,
  key2:value2
}
print(dict)
1
2
3
4
5

字典方法

  • cmp:比较字典
  • len:字典元素个数,也就是key的个数
  • dic.clear():清空字典
  • dic.copy() :返回一个字典的浅复制
  • dic.fromkeys() :创建一个新字典,以序列seq中元素做字典的键,val为字典所有键对应的初始值
  • dic.get() :返回指定key对应的值
  • dic.items() :以列表返回可遍历的(键, 值) 元组数组
  • dic.keys() :返回所有的key
  • dic.vaule() :返回所有的value
  • dic.setdefault()
  • dic.update(dic2) :把dic2的键和值更新到dic里面
  • dic.pop() :
    • 删除字典给定键 key 所对应的值,返回值为被删除的值。
    • key值必须给出, 否则,返回default值
  • dic.popitem() :随机返回并删除字典中的一对键和值
print(type(dic)) # <type 'dict'>
# 访问数据
# print dic.name 报错:AttributeError: 'dict' object has no attribute 'name'
print(dic['name'])# zs
# print dic['aa'] # 访问不存在的key  报错:KeyError: 'aa'

# 更新数据
dic['name'] = 'ls'
print(dic)# {'age': 18, 'sex': '男', 'id': 1000, 'name': 'ls'}

# 删除元素

# 删除字典
# del dic
# print dic # 报错:NameError: name 'dic' is not defined  因为字典被删除了

# 清空字典
# dic.clear()
# print dic # {}

# 删除指定key
del dic['sex']
print(dic) # {'age': 18, 'id': 1000, 'name': 'ls'}

print(dic.items()) # [('age', 18), ('id', 1000), ('name', 'ls')]
print(dic.keys())# ['age', 'id', 'name']
print(dic.values())# 18, 1000, 'ls']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

NUll和None

NUll

  • Python中是没有NULL的
  • 通常我们认为空字符串是NULL
print(type('')) 
# <class 'str'>
1
2

None

print(type(None)) 
# <class 'NoneType'>
1
2
  • None表示该值是一个空对象,空值是Python里一个特殊的值,用None表示
  • None不能理解为0,因为0是有意义的,而None是一个特殊的空值
  • 你可以将None赋值给任何变量,也可以将任何变量赋值给一个None值得对象
  • None有自己的数据类型NoneType,None和任何其他的数据类型比较永远返回False

TIP

None是没有像len,size等属性的

要判断一个变量是否为None,直接使用if(a == None):即可

null和none比较

  • null和none是不同的一种数据类型
print(type('')) 
# <class 'str'>

print(type(None)) 
# <class 'NoneType'>
1
2
3
4
5
  • null和none判断的时候均是False
a = None
if a:
    print(1)
    
b = ''
if b:
    print(1)
    
# 结果:都不打印
1
2
3
4
5
6
7
8
9
  • 使用dir()函数返回参数的属性、方法列表不一样
print(dir(None))
['__bool__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']


print(dir(''))
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

1
2
3
4
5
6
7

TIP

python是把0,空字符串‘ ’和None都看作False,把其他数值和非空字符串都看作True

运算符

运算符分类

  • 基本运算符
  • 比较运算符
  • 赋值运算符
  • 逻辑运算符
  • 成员运算符

基本运算符

  • + - * / :加减乘除
  • % :取余
  • ** :两个乘号,指数幂,比如2**4 => 2*2*2*2 = 16
  • // :取整除返回商的整数部分,比如10//4,结果2

比较运算符

  • == 比较对象是否相等
  • != 比较对象是否不相等
  • <> 比较对象是否不相等 类似于!=
  • > 大于
  • >< 小于
  • >= 大于等于
  • <= 小于等于

赋值运算符

  • = 直接赋值
  • += 加法赋值运算符 a+=b => a = a + b
  • -= 减法赋值运算符 a-=b => a = a - b
  • = 乘法赋值运算符 a=b => a = a * b
  • /= 除法赋值运算符 a/=b => a = a / b
  • %= 取模赋值运算符 a%=b => a = a % b
  • **= 幂赋值运算符 a**b => a = a ** b
  • //= 取整除赋值运算符 a//=b => a = a // b

逻辑运算符

  • and 与
a = 3
b = 4
c = 5

print(a and b) # 4
print(a and False) # false
print(a and True) # True

print(False and a) # false
1
2
3
4
5
6
7
8
9

TIP

如果and前面的a为真,返回b的值,如果前面的a为假,返回False

  • or 或
a = 3
b = 4
c = 5
print(a or b) # 3
print(a or False) # 3
print(False or a) # 3
print(False or False) # False
1
2
3
4
5
6
7

TIP

如果a为True,返回a的值,否则返回b的值

  • not 非
print(not 4) # False
print(not True) # False
print(not False) # True
1
2
3

TIP

如果not后面是True,返回的是False;not后面是False,返回的是True

成员运算符

  • in 是否在序列中,比如:是否在数组中
    • 如果在指定的序列中找到值返回 True,否则返回 False
  • not in
    • 如果在指定的序列中没有找到值返回 True,否则返回 False

条件判断

基本结构

if 判断条件(表达式):
    执行语句……
else:
    执行语句……
1
2
3
4

注意事项

  • 判断条件条件表达式要求:计算结果必须是布尔值的表达式
  • 表达式后面的冒号不能少

示例代码

str = "ww"
if str == 'zs':
    print('str是zs')
else:
    print('str不是zs') 

if str == 'zs':
    print('zs')
elif str == 'ls':
    print('ls')
elif str == 'ww' or str == 'w1w': # 这里可以用or  and  not 添加多个条件
    print('ww')
else:
    print('qq')# 条件均不成立时输出

str2 = 'w'
if str2 == 'w' : print('==')
    
# 输出结果
str不是zs
ww
==
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

TIP

  • Python中没有大括号代码块,它们是严格按照缩进,来控制代码结构的
  • Python中没有switch case语句,只有if、else

循环语句

Python中的循环语句有两个:while和for

while

基本结构

while 判断条件:
    执行语句……
1
2

示例代码

num1 = 1
while num1 < 5 :
    num1+=1
    if num1 == 3:
        print('num == 3')
    elif num1 ==4:
        print('num == 4')
print('num ==',num1)

# 执行结果
num == 3
num == 4
num == 5 # 循环执行完毕,num 增加变成5
1
2
3
4
5
6
7
8
9
10
11
12
13

for in

for i in 'hel':
    print(i)

for i in ['zs','ls','ww']:
    print(i)

for i in range(1,10):
    if i%2 != 0:
        print(i,'是奇数')
else:
    print("循环正常结束") # 当for循环结束的时候,会执行else语句
    
# 执行结果
h
e
l
zs
ls
ww
1 是奇数
3 是奇数
5 是奇数
7 是奇数
9 是奇数
循环正常结束
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

continue

无条件结束本次循环,从新进入下一轮循环

break

无条件结束整个循环,简称循环猝死

空语句pass

表示略过,通常用于占位,和占位符作用类似

range

创建一个整数列表,具体范围可以指定

range(start, stop[, step])
1
  • start:
    • 计数从 start 开始
    • 默认是从 0 开始
    • 例如range(10)等价于range(0, 10);
  • stop:
    • 计数到 stop 结束,但不包括 stop
    • 例如:range(0, 10) 是[0, 1, 2, 3, 4,5,6,7,8,9],没有10
  • step:
    • 步长,默认为1。
    • 例如:range(0, 3) 等价于 range(0, 3, 1)
for i in range(0,10,3):
    print(i)

# 结果
# 0
# 3
# 6
# 9

print(range(10))
# range(0, 10)
1
2
3
4
5
6
7
8
9
10
11

TIP

range(10),不是返回一个列表(数组),返回的是一个range

定时器(Timer)

执行一次

  • Timer是Thread的一个派生类
  • 规定时间后执行一次函数
# 导入包
import threading
# 定时器调用的一个函数
def hello(name):
    print "hello %s\n" % name
# 参数一:时间
# 参数二:方法名称(记住不要加括号)
# 传递给方法的参数,如果必须有的话,用[]包裹
timer = threading.Timer(2.0, hello, ["xiaofengge"])
# 启动定时器
timer.start()
1
2
3
4
5
6
7
8
9
10
11

TIP

Timer只会执行一次(类似JavaScript的:setTimeout),如果想每隔一段时间就调用一个函数的话(类似JavaScript的:setInterval),就要在Timer调用的函数中,再次设置Time

循环执行定时器

def fn(timeout):
    timeout = timeout -1
    # 倒计时为0,结束循环
    if(timeout <= 0):
        print("结束循环{0}".format(timeout))
        return
    print("倒数:{0}".format(timeout))
    # 循环调用
    timer = threading.Timer(1,fn,[timeout])
    timer.start()
    
# 传递超时时间:5秒
fn(5)
1
2
3
4
5
6
7
8
9
10
11
12
13

TIP

每隔一段时间执行一次函数,是我们经常遇到的一个需求,大家可以多了解实践一下

函数(function)

完成某些特定功能的代码块,可以成为函数

函数的使用需要:函数声明和函数调用

基本结构

# 函数声明
def 函数名(形参):
	语句
	return
	
函数名(参数) # 函数调用
1
2
3
4
5
6
# 函数声明
def sayHello(name):
    print('你好,{0}'.format(name))
    return None

# 简单的一个空方法
def sayHi():
    pass

# 方法调用,传递参数
sayHello('xiaofengge')  # 你好,xiaofengge
sayHi()
1
2
3
4
5
6
7
8
9
10
11
12

函数的参数

参数:是在我们调用函数的时候,传递过去的一些有用的数据或者信息

形参(形式参数)

  • 形参是我们声明函数的时候,添加的参数,相当于占位符

实参(实际参数)

  • 实参是我们调用函数的时候,传递的数据,是我们实际用到的参数
def myFunc(name,age):
    print('你好,我是:{0},我的年龄是:{1}'.format(name,age))
    return None

myFunc('xiaofengge',18)
# 你好,我是:xiaofengge,我的年龄是:18
1
2
3
4
5
6
  • 这里的name和age就是形参
  • xiaofengge和18就是实参

函数的返回值

  • 函数的返回值,使用return关键字来表示
  • 一旦函数执行了return,函数就必须强制停止,结束当前函数,后面的代码不会继续执行
  • 函数中没有return语句,会默认返回一个None
# 函数声明
def sayHello(name):
    print('你好,{0}'.format(name))
    return 'sayHello'
    print('next') # 这里return后面的语句不会被执行

result = sayHello('xiaofengge') # 你好,xiaofengge
print(result) # sayHello
1
2
3
4
5
6
7
8

函数参数分类

  • 普通参数
  • 默认参数
  • 可变参数(list)
  • 命名关键字参数
  • 关键字参数(dict)

TIP

Python中函数参数有多重类型的时候,必须按照一定的顺序传递:

普通参数 -- 默认参数 -- 可变参数\命名关键字参数 -- 关键字参数

普通参数

# 函数声明
def sayHello(name):
    print('你好,{0}'.format(name))

result = sayHello('xiaofengge') # 你好,xiaofengge
1
2
3
4
5
  • 普通参数也叫做必选参数,如果形参有,那么调用函数就必须传递
  • 普通(必备)参数必须以正确的顺序传入函数,调用时的数量必须和声明时的完全一致

默认参数

默认参数必须放在普通参数后面(如果有普通参数)


1

包(package)

面向对象(OOP)

网络爬虫(web crawler)