Python第三章 python的运算符和表达式

运算符：

加减赋值（简单的运算，声明变量）如下：

 

 

 

取最大最小值，（函数调用，函数（参数））单行字符串如下：

 

 

 

判断数据类型如下：

 

 

 

 

三单引号或三双引号编写多行字符串如下：

 

 

 

 

列表（中括号），集合（花括号），字典（花括号）（去重，集合加运算）如下：

 

 

 

import引入摸块关键字，求平方根 .sqrt() 如下：

 

 

 

"""多行注释"""

'''单(多)行注释'''

 

常量：内存 固定值单元  值不变

 

变量：内存 变量的值或地址 值可变

常量命名规范：每个单词全部大写：NAME

变量命名规范：第一个字母必须是字母或下划线，不能是数字或中文

 

变量命名方式：

　　　　　　Python3 支持 uft-8

　　　　　　标识符和关键字：

　　标识符：变量名，函数名，类名，要见名知意，比如name表示名字

　　关键字：Python内部已经使用的标识符

　　　    　　>>>import  keyword     

　　      　　 >>>print（keyword.kwlist）(查看关键字）

　　注意：　区分大小写

　　    　　　= 左右要有空格

　　变量名是多个单词的时候：每个单词使用小写字母，单词之间用下划线分割：first_name

　　驼峰命名法：变量名是两个以上的单词组成时，可以使用驼峰命名法

　　小驼峰命名法：第一个单词以小写字母开始，后续单词首字母大写:firstName，lastName

　　大驼峰命名法：每一个单词的首字母均大写：FirstName，LastName

　　普通变量：全小写字母，单词之间用下划线分割，如my_var;

　　全局变量：全大写字母，单词之间用下划线分割，如MY_CONST;

　　类名：首字母大写，单词直接连在一起，采用驼峰命名法，如MyClass;

　　普通函数：与普通变量一样，如my_function();

　　模块名：全小写字母，不使用下划线;

 

保留字

　　保留字：被编程语言内部定义并保留使用的标识符

　　python语言中有33个保留字(也叫关键字)

　　保留字是编程语言的基本单词，大小写敏感，IF不等于if，if是保留字，IF是变量

　　33个保留字：

　　and　　elif　　import　　raise　　global　　as　　else　　in

　　return　　nonlocal　　assert　　except　　is　　try　　True　　break　　

　　finally　　lambda　　while　　False　　class　　for　　not　　with　　

　　None　　def　　if　　pass　　del　　continue　　from　　or　　yield

　　

 

基本数据类型:

数据类型：数据在内存中的存储方式

基本的数据类型：整型，浮点型，布尔型，复数型，字符串型

数据结构类型：列表，元组，字典

整数型：int 不限制大小 可当作Long使用 包括自然数和负整数

浮点型：如果整数部分为0，则省略：.23=0.23

减法误差的原因：内存中以二进制表示浮点数，有的浮点数表示不精确，所以会产生误差

 

解决误差：可使用decimal模块，但有性能损失

 

 复数类型：

 说明：定义时为实部和虚部为整形，但是内存中存储的却是浮点型

布尔型：使用常量True和False表示

　　布尔型变量可以通过比较表达式获得，True当作1，False当作0

　　

 

 

 

 

整型的其他表示：

十进制：以10为基数，使用0-9，9+1=10

二进制：以2为基数，1+1=10，python中以0b开始：0b01011

　　　　计算方法：1*2⁰ +1*2¹+0*2²+1*2³+0*2⁴=11

八进制：以8为基数，使用0-7，1+7=10，python中以0o开始：0o66

　　　　计算方法：6*8⁰+6*8¹=54

十六进制：以16为基数，0-9，a-f，（A-F）对应10-15，python中以0x开头：0x2F

　　　　计算方法：15*16⁰+2*16¹=47

字符串：数字，字母，下划线

　　　　双引号可生成包含单引号的文本

　　　　

 

 

基本操作：

 

　　　　　加法：拼接字符串

 

　　　　 

 

　　　　　数乘：重复n次字符串

 

　　　　  

　　　　　获取长度：len()函数 

 

 

 　　　　　　　

 

 

转义字符：\ 开头(后可加字符、八进制数、十六进制数)    \n 表换行   \t 制表符  \r 表回车   \\ 反斜杠   \ 结尾时表示续航符   

\' 单引号  \" 双引号　\000 空

 

 

代码的换行：()或\

　　　　

 

 

 　　　　　　 

 

 

字符串的格式化

　　　   简单的字符串拼接：

 

　　　　

 

 

 　　　　　　使用%格式化输出：

　　　　　　   

 

 

 　　　　　　%s  表示字符串

　　　  %d  表示整数

　　　  %f   浮点数

　　　  使用.format()方法格式化：

　　　  

 

 

 

 　　　  通过参数指定位置进行格式化：　　　

　　　　

　　　　多位置替换：

 

 

 　　　  

 

　　　　使用名称对参数格式化：

 

　　　  

 

 

 

 

 

　　　　花括号可以控制输出的类型及各式：

 

　　　　　　{<field name>:<format>}　　

　　　　说明：field name：参数位置或名称，可省略

　　　　　　    Format：可以是s/d/f

　　　　格式化符号：　s字符串　　d整数　　f浮点数

　　　　:10s格式字符串是在后面添加空格

　　　　

 

　　　　:10d是在整数前面添加空格

 

　　　　

 

 

 　　　　　　  :010d是在整数前面添加0，补足位数

　　　　

 

　　　　{:.2f}指定浮点数，小数点后显示2位

 

　　　　

 

 

 　　　　　　Python3中，字符串都是Unicode字符串，16位

 

 

运算符：

　　分类：算术运算符，连接运算符，关系运算符，赋值运算符，逻辑运算符   如：+，-，*，/，%，not，and，or..........

　　算术运算符：对运算数进行算术运算

　　　　+：相加　　

　　　　-：相减　　

　　　　*：两数相乘或重复若干次字符串　　

　　　　/：两数相除　　

　　　　%：求余数　　

　　　　**：幂运算，x**y表示x的y次幂(方)　　

　　　　//：取整除，向下取接近除数的整数    9/2=4，-9/4=-5

赋值运算符：变量的赋值和更新

　　　　基础赋值运算符：=

　　　　特殊赋值运算符：加法赋值运算符，减法赋值运算符........

　　　　=：简单赋值

　　　　+=：加法赋值运算符  c+=a：c=c+a　

　　　　-=：减法赋值运算符   c-=a： c=c-a　

　　　　*=：乘法赋值运算符   c*=a： c=c*a

　　　　/=：除法赋值运算符   c/=a：  c=c/a

　　　   %=：取模赋值运算符  c%=a：c=c%a

　　　　**=：幂赋值运算符　 c**=a： c=c**a

　　　　//=：向下取整除赋值运算符 c//=a：c=c//a　　

　　

　　　　关系运算符：比较运算符，比较数之间的大小及是否相等

　　　　　　　　a=3，b=5

　　　　　　==：等于　　a==b：False

　　　　　　!=：不等于　 a!=b：True

　　　　　　>：大于　　  a>b：False

　　　　　　<：小于　　  a<b：True

　　　　　　>=：大于等于 a>=b：False

　　　　　　<=：小于等于 a<=b：True

　　　　　　注意：所有比较运算符返回1表示真，返回0表示假，与特殊变量True及False等价

　　　　　　Python中的字符使用ASCI码，所以比较的是字符的ASCI码

　　　　　　

 

 

　　　　　　逻辑运算符：判断事物之间与、或、非的关系，包括 and、or、not

 

　　　　　　　　　　a=True   b=False

 

　　　　　　and：布尔与　　x and y　　全真则真，有假则假　　x and y：False

 

　　　　　　or：布尔或　　  有真则真，全假则假　　x or y：True

 

　　　　　　not：布尔非　　 取反　　　　　　　　not(x and y):True

 

　　　　　　     　 　　　　　

注意：

1.没有括号，not>and>or  同一优先级从左到右计算

　　　　　　　　　　　　

 

 2.x or y 有真则真，全假则假，x and y 有假则假，全真则真，非0转换为布尔值是True，0转换为布尔值是False(若全是真or取前边数，全是真and取后边数)

　　　　　　

　　　　

运算符的优先级：

　　　　　　**　　指数(最高优先级)

　　　　　　~*-　　按位翻转，一元加号和减号(+@,-@)

　　　　　　*/%//　　乘，除，求余数，取整除

　　　　　　+-　　加法， 减法

　　　　　　>> <<　　右移，左移

　　　　　　&　　位'AND'

　　　　　　　　　　^　|　位运算符

　　　　　　<= < >= > 　　比较运算符

　　　　　　==  |=　　等于运算符

　　　　　　= %= /= //= -= += *= **=　　赋值运算符

　　　　　　is   is not　　身份运算符

　　　　　　in   not in　　成员运算符

　　　　　　not and or　　逻辑运算符

　　　　　　

 

 

　

 

 

 

数据结构：

　　容器：序列(列表，元组，字符串)、映射(如字典)以及集合(set)

　　数组：大小固定的数据记录组成，根据索引快速查找元素，连续的数据结构

　　列表list：动态数组  添加或删除元素   分配或释放内存来自动调整存储空间

　　优点：可以存储不同数据类型

　　缺点：数据存储不紧凑，数据结构占据空间大

 

 

 列表创建、查询

　　列表：不限类型，可以是字符串或混合型

　　　　

　　索引：指示数据所在位置的逻辑指针，列表的索引就是元素的序列位置

  　　　　　　

　　　　实际问题：当列表内元素较多时，查找最后的元素较麻烦

　　　　解决办法：用负数表示索引，-1表示最后一个数字的索引

 　　　　　　　　

　　问题：怎样一次选择多个元素呢？

　　

　　注意：区间左闭右开，该方法也叫切片

　　省略一个参数的情况：省略冒号前面的参数，代表从索引第一的　　　　　　　　　　　　　 　　参数开始；省略冒号后面的参数，代表直到最后一个元素，但　　　　 　　是遵循左闭右开的原则，所以不包括最后一个元素。

　　

　　

 

 

列表的增删查：

　　增加：insert(one,two) one表示入的索引位置，two表示要插入的值

　　

　　  append(value)：在末尾添加元素

　　

　　　删除：pop([arg])

　　没参数：删除最后一个元素

　　

　　

　　有参数：删除数值对应索引的元素

　　

　　更改：

　　直接对元素赋值

　　

　　如何表示三个学生的信息，要求包括姓名、年龄和性别？

　　两种办法：

　　一维列表：

　　　　

　　　二维列表：

　　

 　　如何创建二维列表？

　　

　　如何更改某一元素

　　

　　原因：具有共同的引用

　　常用的方法：

　　list.append(obj)　　向列表添加某一个元素

        

　　list.count　　查看某一元素在列表中出现的次数

　　

　　list.extend(seq)　　将另一个序列中的元素依次添加到该序列

　　

 　　list.index(obj)　　返回列表中某元素首次出现的索引位置

　　

　　list.insert(index,obj)　　在指定索引插入一个元素，插入位置后的元素依次后移

　　

 　　list.pop(index)　　删除指定位置的元素并返回

　　

　　list.remove(obj)　　删除第一次出现的指定元素，不存在，抛异常

　　

　　　删除不存在的元素会抛异常：

　　

　　list.reverse()　　将列表的元素逆序排列

　　

　　list.sort()　　将元素按照从小到大排序

　　

　　list.clear()　　清空列表

　　

　　list.copy()　　复制列表

　　

 

 

 

元组tuple：

　　元组：在创建时定义元组中的所有元素，不可变，不能添加和删除元素，用圆括号表示

　　优点：可以打包任意类型元素，具有很强的灵活性

　　缺点：打包密度比固定类型密度小

　　

　　注意：不允许修改某个元素的值

　　查询：

　　

　　注意：由于元组不更改的特性，通常作为常量使用，防止修改，更安全

 

 

字典：

　　字典：映射、散列表、查找表、关联数组

　　优点：高效查找、插入、删除关联对象，计算机科学中最重要的数据结构

　　dictionary

　　简称：dict

　　存储方式：key—value键值对    key作为索引存储

　　字典和列表的差异：

　　A.字典以key的形式查找及存储，查询速度非常快，缺点是占用内存大

　　B.列表的查询，元素越多，速度越慢，优点是占用内存空间小

　　C.Dict：空间换时间，list：时间换空间

　　查找方式：通过key，如果key不存在，会报错

　　

　　如何解决：成员判断(in)

　　

　　赋值方法：直接通过key给value赋值

　　

　　key可以修改？  不能

　　删除方式：

　　

　　增加元素：

　　

　　Keys()和value()函数的使用：

　　Keys():返回所有key对应的数组，如果要转换为列表，可以在外层嵌套list()函数

　　

　　Values():返回所有value对应的数组，如果要转换为列表，可以在外层嵌套list()函数

　　

　　items()函数：将key—value对变成tuple形式，以数组输出

　　

　　如何表示更复杂的数据格式呢？　　通过嵌套

　　

　　建议使用内置的dict数据类型，优化的散列表实现，功能多

　　常用方法：

　　clear():　　删除字典内所有的元素

　　

　　copy():　　返回字典的浅拷贝

　　

　　fromkeys(seq,vall):　　创建一个字典，以序列seq中的元素作为字典的键，vall为字段所有键对应的初始值，seq表示序列

　　

　　get(key,default=None)　　用索引查询字典中不存在的键时，显示None

　　

　　key in dict　　　　如果键在字典dict里，返回true，否则返回false

　　

　　setdefault(key,default=None)：　　和get类似，但是如果键不存在字典中，将会添加键并且将值设为default

　　

　　update(dict2)：　　一次更新多个键值对

　　

　　说明：update()方法会更新原来已有的键值对，同时添加原理没有的键值对

　　values():　　返回一个由所有值组成的列表

　　

　　pop(key[,default]):　　pop方法也接收两个参数key和default，其中default参数的默认值None，如果给定的键不存在，方法返回default参数指定的值

　　

　　popitem():　　返回并删除字典的最后一对键和值

　　

 

 

 

 

集合：无序的序列，元素具有唯一性，不存在同样的元素

　　Python规定集合中只能是不可变类型：数字、字符串、元组等、浮点数（精度问题）不适合

　　集合的生成：

　　A：set()

　　

　　B:使用列表

　　

　　说明：集合保证元素的唯一性

　　C：使用一对{}

　　

　　注意：空集合只能使用set()函数创建，空的{}创建的是空的字典

　　

集合的运算

　　

 

 

　　a,b={1,2,3,4},{3,4,5,6}

　　并集："|",可交换

　　a|b

　　

　　b|a

　　

　　a.union(b)

　　

　　交集："&"可交换

　　a.intersection(b)

　　

　　差集："-" 不可交换

　　a.difference(b)

　　

　　对称差集："^" 等于两个集合并集和交集的差  可交换

　　a.symmetric_difference(b)

　　

集合的包含关系

　　子集、真子集

　　子集： <=

　　

　　issubset()判断

　　

　　也可以使用>=或issubset()判断

　　

　　真子集：<　　>

　　

判断从属关系

　　关键字in可判断集合中的从属关系

　　

　　不可变集合：

　　不可变集合(Forzen Set)：一旦创建，不能改变

　　创建方法：

　　

　　用途：作为字典的键

　　

　　不可变集合中元素的顺序不同，不会改变查询结果

　　

　　常用方法：(所有方法的首字母是小写字符)

　　add()　　为集合添加元素

　　

　　clear()　　移除集合中所有元素

　　

　　copy()　　拷贝另一个集合

　　

　　difference()　　返回多个集合的差集

　　difference_update()　　移除集合中的元素，该元素在指定的集合也存在

　　

　　discard()　　删除集合中指定的元素

　　

　　     

　　查询两个方法的异同： intersection() 返回集合的交集intersection_update() 返回集合的交集

　　isdisjoint()　　判断集合是否包含相同元素，有:false  没有:true

　　

　　issubset()　　判断指定集合是否为该方法参数集合的子集

　　

　　issuperset()　　判断方法都参数集合是否是指定集合的子集

　　

　　pop()　　随机移除元素

　　

　　remove()　　移除指定元素

　　区别：remove()和discard()都是对set集合中的元素进行删除，不同的是，remove()方法删除不存在的元素时会报错，但是discard()方法不会报错

　　

　　Symmetric_difference()　　返回两个集合中不重复的元素集合(对称差集)

　　注意：会产生新的集合

　　

　　symmetric_difference_update()　　移除两个集合的相同元素，增加不同的元素(对称差集)

　　注意：不会产生新的集合，在调用的集合对象进行操作

　　Union()　　返回两个集合的并集

　　

　　update()　　给集合添加元素

　　

　　查看两个变量是否来自于同一个地址

　　复制操作时候出现的问题：

　　　　问题：赋值并不能实现真正的复制效果。

 

 

　基本类型的赋值机制：

　　　　X=500

　　　　Y=x

　　　　Y='foo'

　　第一步：x=500

　　内存空间　　　　　　　　　　　　　　命名空间

　　Pos1:pyint(500)　　　　　　　　　　　x:pos1

　　第二步：y=x

　　内存空间　　　　　　　　　　　　　　命名空间

　　Pos1:pyint(500)　　　　　　　　　　　x:pos1  y:pos1

　　第三步：Y='foo'

 

　　内存空间　　　　　　　　　　　　　　命名空间

　　Pos1:pyint(500)　　　　　　　　　　　x:pos1  y:pos2

　　Pos2:pystr('foo')　　　　　　　　　　　

　　

　　验证　　　　

　　使用id()函数可以查看变量内存地址

　　

　　Y和X的id值一样，说明指向同一块内存地址。

　　也可以使用is关键字来判断X和Y是否是同一对象：

　　

　　Y的内存地址发生了变化：

　　

　　值相同，内存地址不同

　　为了提高内存利用效率，Python对于一些简单的对象比如数值较小的整数对象，采用了共用内存的方法

　　

　　容器类型的赋值机制

　　X=[500,5001,502]

　　Y=x

　　Y[1]=600

　　Y=[700，800]

　　基本类型在内存中存储的是相应的值，而容器类型在内存中存储的是值对应的内存地址。

　　容器类型中存储的内存地址是可变的。

　　第一步：

　　X=[500，501，502]

　　内存空间　　　　　　　　　　　　命名空间

　　Pos1:pyint(500)(不可变)　　　　　　x:pos4

　　Pos2:pyint(501)(不可变)　　　　　　

　　Pos3:pyint(502)(不可变)

　　Pos4:pylist(pos1,pos2,pos3)(可变)

　　第二步：

　　Y=x

　　内存空间　　　　　　　　　　　　命名空间

　　Pos1:pyint(500)(不可变)　　　　　　x:pos4

 

　　Pos2:pyint(501)(不可变)　　　　　　y:pos4

 

　　Pos3:pyint(502)(不可变)

 

　　Pos4:pylist(pos1,pos2,pos3)(可变)

　　第三步：

　　Y[1]=600

　　内存空间　　　　　　　　　　　　命名空间

　　Pos1:pyint(500)(不可变)　　　　　　x:pos4

　　Pos2:(垃圾回收)　　　　　　　　　　y:pos4

　　Pos3:pyint(502)(不可变)

　　Pos4:pylist(pos1,pos5,pos3)(可变)

　　Pos5:pyint(600)

　　第四步：

　　Y=[700，800]

　　内存空间　　　　　　　　　　　　命名空间

　　Pos1:pyint(500)(不可变)　　　　　　x:pos4

　　Pos2:(垃圾回收)　　　　　　　　　　y:pos8

　　Pos3:pyint(502)(不可变)

　　Pos4:pylist(pos1,pos5,pos3)(可变)

　　Pos5:pyint(600)

　　Pos6:pyint(700)(不可变)

　　Pos7:pyint(800)(不可变)

　　Pos8:pylist(pos6,pos7)(可变)

　　验证：

　　

　　修改y[1]，id[y]不变

　　

　　而id(x[1])和id(y[1])的值都变为一个相同的新值：

　　

　　更改y的值，id(y)会改变，id(x)不变

　　

　　其他类型的情况

　　除了列表。　　字典，集合等的赋值也采用了类似的机制：

　　

　　对于比较大的列表、字典或集合，复制所有的元素通常比较耗时，也占用了额外内存，所以直接让他们共享一块内存的赋值机制显得更高效。

　　要想真正实现复制，可使用生成函数生成新的对象：

　　集合使用set()函数：

　　

　　列表使用list()函数：

　　

　　字典使用dict()函数：

　　

 

 

内置函数与自定义函数

　　编程语言的函数分类：

　　内置函数：Python中直接可调用的函数，比如print(),max()........

　　自定义函数：程序员将一些功能封装成函数反复调用，自己编写的函数

　　数字相关的内置函数

　　绝对值：abs(x)

　　x：整数、长整数、浮点数、如果是复数(a+bj)，返回模：a+b的算术平方根²²

　　

 

进制的转换

 

　　bin(),oct(),hex()：分别将整数转换为2进制、8进制、16进制的字符串

 

　　

　　ASCII码与字符的转换

　　cha():将ASCII码转换为相应字符

　　ord():将单个字符转换为相应的ASCII码

　　

 　　拓展：unicode字符的转换：unichr()　　ord()

商和余数的计算

　　divmod(a,b)：返回一个元组

　　参数是整数：(a/b,a%b)

　　参数是浮点数：(q,a%b)　　q是a/b向下取整　　由于浮点数的问题，q可能比实际小1

幂的计算

　　pow(w,y[z])

　　没有z函数返回x的y次方，x**y

　　有z函数返回x的y次方模z(余数)

　　

 

 

　　说明：pow(2,5,10)要比pow(2,5)高效

 

近似值的计算

 

　　round(num[ndigts])

 

　　Num：计算对象

 

　　Ndigts：小数点后保留的位数，默认为0，返回整数

 

　　

　　由于浮点数精度问题，有时候会出现不符合规则设定的问题：

　　

　　规定：round()函数规定将数字近似到离0更远的那个数，如果距离0和那个数距离相等，则保留到偶数的一边

　　

与序列有关的内置函数

　　序列的真假判断：

　　all()：序列中所有元素都计算为真，返回true，否则，返回false

　　any()：序列中的任意一个元素为真，返回true，否则，返回false

　　判断真假的规则和判断语句中的判断条件一致。

　　

迭代对象的生成

　　range()：该函数返回的是一个可迭代对象，不是列表对象，所以无法打印列表

　　解决办法：

　　使用：list()函数把range()返回的可迭代对象转换为一个列表，返回的变量类型为列表。

　　

　　序列的迭代

　　enumerate()：可以在迭代序列时候输出序号和值

　　

　　说明：可在函数中指定序号开始值，如enumerate(x,1)表示是基数从1开始

　　

　　zip()：可以将两个序列放再一起进行迭代

　　

 序列的最值

　　max()：求序列最大值

　　min()：求序列最小值

　　

 序列的切片

　　slice()

　　调用切片时，使用start:stop:step,可以使用slice()函数生成slice对象，如5:10:2

　　

 序列的排序与逆序

　　sorted()：对序列进行排序，返回列表

　　reversed()：将列表反序排列，返回列表

　　

 求序列的和

　　sum()：对序列中的所有元素求和

　　

 与类型相关的内置函数

类型判断

　　isinstance()

　　与基本类型相关的内置函数主要有int、bool、long、float、set、dict、list、tuple、frozenset、file等，他们可以初始化一个实例，也可以配合函数isinstance()来判断一个对象是否为指定的类型

　　

 类型转换

　　int()：可将浮点数转换为整数型，但只保留整数部分

　　

 　　float()：整形转浮点型

　　

 　　complex()：整数型、浮点型转复数型

　　

 数字与字符串的相互转化

　　数字转字符串

　　str()

　　repr()

　　

 　　区别：repr()返回适合解释器的阅读表示，str()返回常规的人阅读的形式，repr()将字符串外层封装了一层引号

　　

 　　整数到其他进制字符串的转换函数：

　　

　　字符串转数字：

　　int()：可将字符串转成整数，默认按照十进制进行转化，也可指定进制进行转换

　　

 　　float()：可将字符串转换为浮点数

　　

 　　ASCII码与字符串的相互转化

　　ASCII：美国信息交换标准代码，用0-255表示单个字符，ord()函数可以查看单个字符的ASCII码值

　　

 　　反之，chr()函数将0-255的ASCII码转成字符串

　　

 

 

 

 

自定义函数

　　函数：完成特定任务的代码单元，具有一定的独立性，通过名称进行调用，一个小括号接收参数，并得到返回值

　　函数的表达定义规则：

　　A：使用关键字def引导

　　B：def后是函数名，括号中是函数的参数，不同的参数使用逗号分隔开，参数可以为空，括号不可省略

　　C：函数的代码块要缩进

　　D：用一对''""包含的字符串作为函数的说明，解释函数的用途，可省略，在查看函数帮助时会显示

　　E：使用关键字return返回一个特定的值，如果省略，返回None

　　

函数的调用

　　说明：函数不会自动执行，需要调用。调用时使用函数名加括号的形式，参数放在括号中:

　　Python不限制函数参数的输入类型，但是传入的参数要支持相应的操作

　　

　　传入的参数不支持加法时：

　　

　　公报异常：

　　

　　传入的参数数目与实际不符时

　　

 

　　

　　传参时，有两种模式：

　　一：按照参数顺序传入

　　二：使用键值模式，按照参数名称传入

　　

 

　　运行后的结果如下：

　　两种方式可以混用：

　　

　　混用时，注意不能给同一个值赋值多次，否则会抛异常

 　　、

　　

带默认参数的函数

　　可以给函数的参数设定默认值，默认参数需要在定义时候设置。

　　 

            

 

 接收不定数目参数的函数

　　比如：max()、min()、sum()

　　实现方法：定义函数时使用"*"实现

　　

 

 

　　说明：其中的*ys是一个可变数目的参数，可以把他看作一个元组

 

　　任意键值作为参数的实现方法：定义函数时使用"*"来实现

 

　　　　　

 　　说明：**ys：不定名字的参数，本质是一个字典。

　　调用add(1,y=3,u=5,w=4)时，ys为字典{'y':3,'u':5,'w':4}

　　以上两种方式可以混用，不过要按顺序传入参数，后传入关键字参数

　　

 

　　

　　反之：也可以以元组或字典前加*作为参数传递给函数

　　

返回多个值的函数

　　函数可以返回多个值

　　

 

 

 

 

 

 

import与自定义模块

　　import导入模块

　　import模块名1[as 别名 1]，模块名2[as 别名 2]，.....：

　　该语句会导入指定模块的所有成员(变量、函数、类.....)，不仅如此，使用模块中的成员时，需要该模块名(或别名)作为前缀，否则python解释器会报错。

　　

　　from 模块名 import 成员名 1[as 别名 1]，成员 2[as 别名 2]，....

　　这种语法格式的import语句，只会导入模块的指定成员。同时，使用该成员时候，无需添加任何前缀，直接使用成员名或别名即可

　　from模块名import*  可导入指定模块所有成员，不推荐

 

　　import   模块名   as   别名

　　导入整个模块

　　

 

　　

　　导入整个模块时，也可以为模块指定别名

　　

　　

　　可以一次导入多个模块，模块之间用逗号隔开

　　

　　导入多个模块时，为模块指定别名

　　

　　

　　from   模块名   import   成员名   as   别名

　　

　　导入成员的时候，也可以为成员指定别名

　　

　　使用from...import导入成员时，支持一次导入多个成员

　　

　　一次导入多个成员时，也可指定别名，同时使用as关键字为成员指定别名

　　

　　使用from...import导入模块所有成员(不推荐)

　　

　　该方式导入所有成员具有风险

　　moudle1　　foo()

　　moudle2　　foo()

　　调用foo()方法时到底哪个模块？因此导入指定模块所有成员是有风险的。

　　如何解决该问题？

　　import   module1

　　import   module2as m2

　　module1.foo()

　　m2.foo()

　　或者用from...import语句也是可以的：

　　from   moudle1   import   foo   as   foo1

　　from   moudle2   import   foo   as   foo2

　　foo1()

　　foo2()

 

自定义模块

　　说明：python模块就是python程序，换句话说，只要是python程序，都可以作为模块导入

　　demo.py

　　

　　

　　test.py

　　

　　

　　存在的问题：测试代码不应该被执行。

　　如何解决该问题？

　　借助内置变量：__name__,直接运行模块时，值为__main

　　模块被导入其他程序中并运行该程序时，模块中的__name__变成了模块名。

　　增加判断：

　　

自定义模块编写说明文档

　　在模块开头位置，使用三引号包裹说明文档：

　　demo.py

　　

 

 

访问说明文档：

 

　　使用模块的"__doc__"属性，访问模块的说明文档。

 

　　test.py

 

　　

　　输出结果：

　　

 

单词出现频率的统计程序：