引用：

在Python中，值是靠引用来传递的，可以用id()查看对象的引用是否相同，id是值保存在内存中那块内存地址的标识

1、对于python来讲，在python当中，所有的东西都是对象（变量、函数、字典……），在函数调用的时候，实参传递的是对象的引用。

2、了解了原理之后，就可以更好的去把控在函数内部处理是否会影响到函数外部的数据变化。

3、参数传递是通过对象引用来完成的

4、对于可变对象来说（列表、字典、字符串），在函数内部对对象进行加工，可以改变对象。

1、局部变量，就是在函数内部定义的变量[作用于仅仅局限在函数内部]

2、不同的函数，可以定义相同的局部变量

pro='计算机信息管理'

name='吴老师'

def printinfo():

      name='peter'

      print('{}.{}'.format(name, pro))

      pass

def TestMethod():

      name='刘德华'

      prin(name,pro)

      pass

3、局部变量的作用，为了临时的保存数据，需要在函数中定义，来进行存储。

4、如果在函数的内部要相对全局变量进行修改，必须要用到global关键字进行声明

def changeglobal():

      global pro

      pro='市场营销’

      pass

------------------------------------

全局变量：

1、可作用于当前文件的所有函数中；

2、当全局变量和局部变量出现重复定义时，系统优先使用局部变量（函数内部定义的变量），强龙不压地头蛇。

输出：

1. 占位符：%，%号后加变量类型

%s：字符串

%d：有符号的十进制整数

%E：索引符号（大写）

%e：索引符号（小写）

%f：浮点实数

%g：%f和%e的结合

print('我的名字是%s：今年【%s】岁'%(strName,strClass))

有多少个占位符后面就有多少个引用

2.换行：\n

3.格式输出：.format()

输入：input('提示语')

转换数据类型为整型：int()

赋值运算符：

赋值：=

加法赋值：+=

a+=c 相当于 a=a+c

幂等赋值：**=

a**=c 相当于 a=a的c次方

逻辑运算符，运算结果是布尔值：

and、or、not

优先级：

not > and > or

从左到右 

算数运算符

加法：+

减法：-

乘法：*

除法：/

求余数：%

求指数：**

相除取整（地板除）：//

比较运算符：

等于：==

不等于：!=

大于：>

小于：<

大于等于：>=

小于等于：<=

按顺序赋值：

a,b=10,5

b=() #元组类型

b=[] #列表类型

b={}#字典类型

变量的命名规则：

1. 以字母/下划线开头，不能用数字
2. 区分大小写
3. 关键字不能用作变量名

定义规则：变量名 = 数据

赋值的时候不需要指定数据类型

type()，查询变量的数据类型

函数的分类：根据函数的返回值和函数的参数

#有参数无返回值的

#有参数有返回值的

#无参数有返回值的

#无参数无返回值的

函数返回值

概念：函数执行完以后，会返回一个对象，如果在函数的内部有return,就可以返回实际的值，否则返回一个空（None);

返回值的类型：任意类型

类型：返回值类型应该取决于return后面的类型

用途：给调用方返回数据

在一个函数内可以出现多个return值，但是肯定只能返回一个return

如果在一个函数体内执行了一个return，意味着函数就退出了，return后面的代码语句将不会执行。

关键字可变参数

用两个*定义

在函数体内，关键字参数是一个字典类型

key值必须是一个字符串 key是一个字符串

def keyFunc(**kwargs):

      print(kwargs)

      pass

调用

dictA={"name":"leo", "age":35}

keyFunc(**dictA)

或者

keyFunc(name='peter','age'=35)

def complexFunc(*args, **kwargs):

可选参数必须放到关键字可选参数之前；

可选参数接受的是元祖类型数据（或者接收后将数据转换为元组处理）

关键字可选参数接受的是字典型数据，或者将接受的数据转换为字典处理

调用时会根据实际参数的格式自动匹配到对应的形参类型。

complexFunc(age=36)

{'age':36}

函数定义：

def 函数名（参数列表）：0-n个

      代码块

函数的参数：

必选参数、默认参数（缺省参数）、可选参数、关键字参数

参数：函数为了实现某向特定的功能所必须的外部数据。

函数相当于一个房间，参数相当于这个房间的入口

def sum(a, b): 形式参数：只是意义上的一种参数，在定义的时候不占内存地址的。

      sum=a+b

      print(sum)

函数调用在调用的时候必选参数，是必须要赋值的

sum(20, 15)

#20和15就是实际参数，占用内存地址，是实实在在的参数

默认参数[缺省参数]

def sum(a=20, b=30):

      print('默认参数试用=%d'%(a+b))

      pass

# 默认参数调用

sum1(10)

默认参数试用40

# 在调用的时候如果未赋值，就会用定义函数时给定的值

缺省参数始终存在于参数列表的尾部；

可选参数（不定长参数）：当参数的个数不确定时试用，比较灵活

def getcomputer(*args):

.

什么是函数：一系列Python语句的组合，可以在程序中运行一次或者多次，一般是完成具体的独立的功能。

为什么要使用函数

打吗的复用最大化以及最小冗余代码，整体代码结构清晰，问题局部化

函数定义：

def 函数名():

      代码块

def + 关键字 +小括号 + 冒号 + 换行缩进 + 代码块

函数的调用：

函数名加（）即可调用该函数

先存在，再使用：先定义，再调用

函数说明文档：

函数内容的第一行可以用字符串进行函数说明

函数的参数：

定义函数的时候，我们把参数的名字和位置确定下来，函数的接口定义就完成了。对于函数的调用者来说，只需要知道如何传递正确的参数，以及函数将返回什么样的值就够了。

Python的函数定义非常简单，但灵活度却非常大，除了正常定义的必选参数外，还可以使用默认参数、可变参数和关键字参数、使得函数定义出来的接口，不但能处理复杂的参数，还可以简单化调用者的代码。

缺省参数:

缺省参数，在调用函数时如果没有传参数，那么会使用定义函数时给的缺省值。缺省参数必须在参数列表的最后面，否则会报错。

不定长参数：

一个函数有时候会处理比当初声明的参数要多，这就是不定长参数，定义函数时不用生命参数名，加了星（*）的变量args会存放所有未命名的变量参数，args为元组；再加**的变量kwargs会存放命名参数，即形如key-value的参数，keywargs为字典。

引用传参：

Python中函数参数是引用传参（注意不是值传递）。对于不可变类型，因变量不能修改，所以运算不会影响到变量自身，而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量。

列表、元组、字符串是序列，有序的数据集合，因为有序，所以就有了索引，index,由此可以对这些序列进行切片处理。

元组是不可变的序列，存储固定的数据，使用频率不高；

字典不是序列，不能用切片操作；

函数：

是最基本的一种代码抽象的方式

传数、调用、不定长参数

return

缺省参数和不定长参数

IDE:集成开发环境

单行注释：#

快捷键ctrl+/

多行注释：'''或者"""，开始结束都需要

对于之前版本的python，有两种特殊的注释

1. 指定python解析器的路径：

#!/isr/bin/python3

2. 指定编码格式：

#-*-coding=utf-8 -*-

进入python环境：win+R，在输入框内输入“Python”

退出python交互式环境：exit()或者quit()

在cmd节目快速获得当前文件夹路径：选中文件夹地址，然后输入“cmd”再按回车

执行python文件：声明一个".py"结尾的文件，可以保存python代码，打开命令提示符，进入要执行文件的本地目录，然后在命令行后面直接输入python 文件的名字.py

从cmd进入所在文件夹（D盘为例），基本的dos命令：
输入“d:”回车
输入“cd 所在文件夹名称”回车（cd：进入目录）

公有方法的操作：

相加操作

strA='人生苦短'

strB='我用python'

strA+strB

listA+listB

元组也可以

复制，用*

print(strA*3)

判断某元素是否在某个数据集中，用in

print('生’ in strA)

True

字典查找key

字典不是序列

字典dict是Python中的一种数据类型，可以存储任意对象。字典是以键值对的形式创建的{'key':'value'}利用大括号包裹；

通常使用键来访问数据，支持增、该、删

在字典中查找某个元素时，是根据键、值。字典的每个元素都由：键、值2个部分组成。

访问值的安全方式get方法，在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值；

特点：

1、不是序列类型，没有下标概念，是一个无序的键值集合，是内置的高级数据类型；

2、用{}表示字典对象，每个键值对用逗号分隔

3、键必须是不可变的类型（元组、字符串）

4、每个键是唯一的，如果出现重复的键，后者会覆盖前者。

注意点：

1、字典的键（key）不能重复，值(value) 可以重复。

2、字典的键（key)只能是不可变类型，如数字、字符串、元组。

字典的常用方法：

修改元素（字典中的值是可以修改的，通过键找到对应值修改）

新增元素（如果在使用变量名['键']=数据时，这个键在字典中，如果不存在就会新增这个元素；

删除元素：del删除指定元素clear清空字典

获取键：keys：python3返回一个包含字典所有key值的dict keys对象，用for循环取出每个key值。

获取键值对：python3返回一个包含所有（键，值）元组的列表dict items对象；

统计个数：len()可以查看字典中有几个键值对

获取值values：python3版本中试用values返回一个包含所有值（value)的dict values对象

删除指定键：pop（‘键’）删除指定键

dictA={}空字典

dictA['name']='李易峰'

{'name':'李易峰‘}

获取所有的键：

print(dictA.keys())

获取所有的值:

print(dictA.values())

获取所有的键和值：

print(dictA.items())

输出键值对

for key,value in dictA.items():

     print('%s==%s'%(key,value))

dictA.update({'age':32})更新（增加）

如何对字典排序

sorted()排序

按照键来排，

sorted(dictA.items(),key=lambda d:d[0])

按照值来排

sorted(dictA.items(),key=lambda d:d[1])

元组tuple:元组是用小括号来声明的，通过下标访问其中的元素；元组中的元素不能修改（列表可以）。

元组的创建很简单，只要在括号中添加元素，用逗号分隔就可以；

元组的内置方法count，计算元素在元祖中出现的次数。

元组的内置方法index查找指定元素在元祖中的下标索引。

元组是不可变的序列，创建后不能修改

当元组中只有一个元素时，要加上逗号，不然，以后解释器会当做整型来处理

支持切片操作

内容可以是任何数据类型

print(tupleA[::-2])从右往左各两个取一个；负号代表方向，从哪个方向取，数字代表步长（2的意思就是每两个取一个）；

可以对元组中的列表进行修改；