注释

多行注释

使用’’’ ‘’’

注释的作用

提高可读性、效率方便调试

变量和数据类型

变量

什么是变量? 变量其实就是个盒子，里面可以装各种东西，装了苹果，箱子和其他东西结合的时候就是属于苹果；装了香蕉，箱子和其他东西结合的时候，就是属于香蕉。 在python当中变量的概念和初中代数方程变量是一致的。 只不过在计算机中，变量不仅仅可以是数字，还可以是其他的任意类型。 变量 = 存储的数据 变量是一段有名字的连续存储的空间，我们可以通过定义变量来申请并命名这样的存储空间，并通过变量的名字来使用这段存储空间。 变量是程序中临时存放数据的场所。变量如何来定义和使用 定义： 变量名 = 数据 变量是可以多次赋值的变量命名规则 必须以字母或下划线开头； 不能以数字开头！ 区分大小写；不能以关键字命名；

数据类型

元组 b = ()列表 c = []字典 d = {}

python基本操作运算符

算术运算符

比较运算符

结果是一个bool类型

逻辑运算符

and 都是真才是真 or 一个真就是真 not 取反 优先级： （）> not > and > or

赋值运算符

c += a ----- c = c+a

python输入和输出

格式化输出

% 占位符，%后面跟的是变量类型%s 字符串类型%d 整形%f 浮点型 name = '老夫子' QQ = '66666666' phone = '546546' addr = '重庆市万州区' print("姓名：%s"%name) print("QQ：%s"%QQ) print("地址：%s"%addr) print("电话：%s"%phone) .format（） name = '老夫子' QQ = '66666666' phone = '546546' addr = '重庆市万州区' print('姓名：{}'.format(name)) print('QQ：{}'.format(QQ)) print('电话：{}'.format(phone)) print('地址：{}'.format(addr))

输入

input

流程控制结构

流程：计算机执行代码的顺序 流程控制：对计算机代码执行顺序的管理，只有流程控制才能实现在开发当中的业务逻辑 流程控制的分类：顺序流程；选择/分支流程；循环流程

顺序流程：代码自上而下的执行结构，default分支流程：根据在某一步的判断，有选择的去执行相应的逻辑的一种结构 单分支：if 条件表达式： 双分支：if else 多分枝：if elif~~else 条件表达式：比较/逻辑/符合 运算符循环流程：在满足一定的条件下，一直重复的去执行某段代码的逻辑 while 条件表达式： 一条条的代码 一条条的代码 一条条的代码 ······· for ··· in 可迭代的集合对象： 一条条的代码 一条条的代码 一条条的代码 ······

循环

语法特点

有初始值有条件表达式循环内计数变量要自增或自减，否则会造成死循环

使用条件

循环的次数不确定，要依靠循环条件来结束

循环目的

为了将相似或者相同的代码操作变得更加简洁，使得代码可以重复利用

for循环

使用条件

适用于已知的循环次数【可迭代对象遍历】

语法特点

遍历操作，依次的取集合容器中的每个值

range

此函数可以生成一个数据集合列表 range（起始值，结束，步长） 数据左包含，右不包含

break

退出循环

continue

跳过本次循环，继续下一次循环

作业

猜年龄小游戏 1.允许用户最多尝试三次 2.三次之后，如果还没猜对，就问用户是否还继续想玩，如果回答Y，让他再玩三次，以此往复；如果回答N，就退出程序 3.如果猜对了，就直接退出 age=30 times=0 while times<=3: temp = int(input("猜猜我几岁了：")) if temp == age: print("恭喜你猜对了！") break pass elif temp>age: print('猜大了，请再试试！') else: print("猜小了，请再试试！") times+=1 if times==3: choose = input('想不想继续猜呢？Y/N') if choose == 'Y' or choose == 'y': times==0 pass elif choose == 'N' or choose == 'n': times==4 else: print('请不要乱输入！') 小王身高1.75m，体重80.5KG。请根据BMI公式（体重除以身高的平方）帮小王计算他的BMI指数，并根据BMI指数： 低于18.5 过轻 18.5-25 正常 25-28 过重 28-32 肥胖 高于32 严重肥胖 用if-elif判断并打印结果 height=float(input('请输入你的身高：')) weight=float(input('请输入你的体重:')) BMI = weight/(height**2) print(BMI) if BMI<18.5: print('过轻') elif 18.5<=BMI<25: print('正常') elif 25<=BMI<28: print('过重') elif 28<=BMI<32: print('肥胖') elif BMI>=32: print('严重肥胖')

高级数据类型

序列

在python当中，序列就是一组按照顺序排列的值【数据集合】 在python中存在三种内置的序列类型：字符串，列表，元组（字典不属于序列范畴） 序列优点：可以支持索引和切片操作 特征：第一个正索引为0，指向的是左端，第一个索引为负数，指向的是右端

字符串及常用方法

切片

截取字符串中的其中一段内容,可以根据下标获取序列对象的任意【部分】数据。 [start：end：step] step默认为1 print(strMsg[::-1]) 倒序输出，符号表示方向，从右往左去遍历

字符串及常用方法

strip() 去除字符串中的空格【lstrip（）删除左边的，右边同理】capitalize()首字母变大写id（）查看内存地址find（）查找是否在字符串中，返回的是下标值（找到一个就break），没找到返回-1index（）检测字符串中是否包含子字符串，返回的是下标值，没找到报错startwith（）是否以。。。开始，返回boolendwith（）是否以。。。结尾，返回boollower（）转换成小写upper（）转换成大写

列表及常用方法

list是一种有序的集合，可以随时添加或删除元素 特点： 支持增删改查； 列表中的数据是可以变化的【数据项可以变化，内存地址不变】 用[]表示列表类型，数据项之间用逗号分割

常用方法

len（）返回列表对象的数据个数，也可以返回字符串中字符的数量append（）追加（列表可以多级嵌套）insert（）插入（位置，数据）extend（）扩展—批量添加修改：list[位置]=要修改的内容del list[下标] 删除 / 也可利用切片批量删除remove（）移除 参数是具体的数据值pop（）移除指定的项 参数是索引值，不加参数删除最后一个index（）索引，返回下标

元组

元组是一种不可变的序列，在创建之后不能做任何的修改元组用（）创建，数据项用，分割可以是任何类型当元组中只有一个元素是，要加上逗号，不然解释器会当做整形来处理通用可以支持切片操作

元组的查询

可以通过下标取可以对元组中的列表进行修改 tuple[1][2]unt() ：统计数据项出现几次

字典及常用方法

字典也是python中重要的数据类型，字典是由 键值对 组成的集合，通常使用键来访问数据，效率非常高，和list一样，支持对数据的添加，修改，删除 特点：

不是序列类型，没下标概念，是一个无序的键值集合，是内置的高级数据类型；用{}|来表示字典，每个键值用逗号分割键必须是不可变的类型，值可以是任何类型每个键必定是唯一的，如果存在重复的键，后者就会覆盖前者key（）获取所有的键value（）获取所有的值items() 获取所有的键值对update（）可以添加或者更新删除 del dectA[’ ']pop() 通过指定键进行删除sorted（）排序 sorted(dictA.items(),key=lambda d:d[0]) #键值按照ASC码排序了

共有操作

合并操作+

复制*

in判断

函数

函数基础

函数：一系列python语句的组合，可以在程序中运行一次或多次，一般是完成具体的独立功能为什么要使用函数：代码的复用最大化，最小化冗余代码，整体代码结构清晰，问题局部化函数定义 def 函数名(): 函数体 函数调用：函数名（）

函数参数

def printInfo(name,height,weight,hobby): print('%s的身高是%f' % (name,height)) print('%s的体重是%f' % (name,weight)) print('%s的爱好是%s' % (name,hobby)) pass printInfo('郑学鸿',173,62,'吉他')

参数分类：必选参数、默认参数、可选参数、关键字参数

必选参数 def sum(a,b): #形式参数:只是意义上的一种参数，在定义的时候是不占内存地址的 sum = a+b print(sum) pass sum(20,15) sum(60,20) 默认参数 def sum1(a=20,b=30): print('默认参数使用=%d'%(a+b)) pass sum1(10) 40 可变参数 # 可变参数(当参数的个数不确定时使用，比较灵活） # 接受的元组类型 def getComputer(*args): #args 可变长的参数类型 print(args) result=0 for item in args: result+=item pass print('result=%d'%result) pass getComputer(1,2,3,4,5,6) 关键字可变参数 #关键字可变参数 # **来定义 # 在函数体内 参数关键字是一个字典类型， key是一个字符串 def keyFunc(**kwargs): print(kwargs) pass # 调用 # keyFunc(1,2,3) 不可以传递 dictA={'name':'leo','age':35} keyFunc(**dictA) keyFunc(name='peter',age=26) keyFunc()# 不传也可以，出来空字典 组合使用 def complexFunc(*args,**kwargs): print(args) print(kwargs) pass complexFunc(1,2,3,4,name='郑学鸿') complexFunc(age=36) # 可选参数*args 必须放在关键字可选参数**kwargs之前,否则报错

函数返回值

概念：函数执行完以后会返回一个对象，如果在函数的内部有return 就可以返回实际的值，否则返回None类型：可以返回任意类型。返回值类型应该取决与return后面的类型用途：给调用方返回数据在一个函数体内可以出现多个return值，但是肯定只能返回一个return如果在一个函数体内，执行了return，意味着函数执行完成退出了 #函数返回值 def sum(a,b): sum=a+b return sum # 将计算的结果返回 pass # rs=sum(10,30) #将返回值赋值给其他变量 # print(rs) #函数的返回值返回到调用的地方 def calComputer(num): result=0 i=1 while i<=num: result+=i i+=1 pass return result value=calComputer(10) print(value) return后面跟的什么就是返回什么数据类型

函数嵌套调用

# 函数嵌套 def fun1(): print('-----------------fun1 start--------------------') print('-----------------执行代码省略--------------------') print('-----------------fun1 end--------------------') pass def fun2(): print('-----------------fun2 start--------------------') fun1() print('-----------------fun2 end--------------------') pass fun2() -----------------fun2 start-------------------- -----------------fun1 start-------------------- -----------------执行代码省略-------------------- -----------------fun1 end-------------------- -----------------fun2 end--------------------

作业

写函数，接收n个数字，求这些参数数字的和 def sumFunc(*args): result=0 for item in args: result+=item pass return result rs=sumFunc(1,2,3,4) print('rs={0}'.format(rs)) 写函数，找出传入的列表或元组的奇数位对应的元素，并返回一个新的列表 def oddlist(con): ''' 处理列表数据 :param con: :return: ''' listNew=[] for item in con: if item%2==1: listNew.append(item) pass return listNew rs3=oddlist([1,2,3,4,5,6,7]) print(rs3) rs4=oddlist(tuple(range(10,30))) print(rs4) 写函数，检查传入字典的每一个value的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。PS：字典中的value只能是字符串或列表 def checkDict(**kwargs): ''' 处理字典value长度 :param kwargs: 字典 :return: ''' result = {} for key,value in kwargs.items(): if len(value)>2: result[key]=value[:2] pass else: result[key]=value pass return result dictOBJ={'name':'郑学鸿','hobby':['唱歌','跳舞','编程'],'pro':'电子信息'} print(checkDict(**dictOBJ))

函数2

函数的基本类型

有参数无返回值的：设置某些不需要返回值的参数设置有参数有返回值的：计算型无参数有返回值的：数据采集（获取系统信息）无参数无返回值的：提示信息打印

局部变量和全局变量

局部变量

在函数内部定义的变量，作用域仅仅局限在函数的内部； 不同的函数可以定义相同的局部变量，但是他们的定义是各自用各自的，不会产生影响； 局部变量的作用：为了临时的保存数据 需要在函数中定义来进行存储

def printInfo(): name='peter' print('{}'.format(name)) pass def TextMerhod(): name='郑学鸿' print(name) printInfo() TextMerhod()

全局变量

与局部变量区别：作用域的范围不同

函数内部和外部的全局变量名字一样的时候，局部变量优先。 pro='电子信息' name='lm' def printInfo(): name='peter' print('{}.{}'.format(name,pro)) pass def TextMerhod(): name='郑学鸿' print(name) printInfo() TextMerhod() peter.电子信息 郑学鸿

在函数内部修改全局变量

利用global关键字

pro='电子信息' name='lm' def printInfo(): name='peter' print('{}.{}'.format(name,pro)) pass def TextMerhod(): name='郑学鸿' print(name) def changeGlobal(): global pro pro='市场营销' changeGlobal() print(pro) printInfo() TextMerhod()

引用

在python当中，万物皆对象，在函数调用的时候，实参传递的就是对象的引用；了解了原理之后，就可以更好的去把控在函数内部的处理是否会影响到函数外部的数据变化参数传递是通过对象引用来完成的

匿名函数

python中使用lambda关键字创造匿名函数 特点：

使用lambda关键字创建，不需要名字；匿名函数冒号后面的表达式有且只有一个（是表达式不是语句）；匿名函数自带return，而这个return的结果就是表达式计算后的结果. 缺点：lambda只能是单个表达式，不是一个代码块，lambda的设计就是为了满足简单函数的场景；仅仅能封装简单的逻辑，复杂逻辑实现不了，必须使用def来实现 M=lambda x,y:x+y print(M(3,5))

三元操作符与lambda表达式

age=15 print('可以参军' if age>18 else '继续上学') A=lambda x,y: x if x>y else y print(A(10,9)) A=(lambda x,y: x if x>y else y)(10,9) print(A)

递归函数

如果在一个函数内部不调用其他函数，而是自己本身 递归必须有一个结束条件 优点：逻辑简单、定义简单 缺点：容易导致栈溢出，内存资源紧张 求阶乘

循环 def factorial(n): result=1 for item in range(1,n+1): result*=item return result number=int(input('请输入一个正整数：')) print(factorial(number)) 递归 def factorial(n): if n==1: return 1 return n*factorial(n-1) number=int(input('请输入一个正整数：')) print(factorial(number))

斐波那契数列的递归实现

def fab(n): if n<1: print('输入有误！') return -1 if n==1 or n==2: return 1 else: return fab(n-1)+fab(n-2) numbers=int(input('请输入一个正整数：')) print(fab(numbers))

递归求解汉诺塔

def hanoi(n,x,y,z): if n == 1: print(x,"--->",z) else: hanoi(n-1,x,z,y) #将前n-1个盘子从X移动到Y上 print(x, '--->', z) #将最底下的一个盘子从X移动到Z上 hanoi(n-1,y,x,z) #将Y上的n-1个盘子移动到Z上 n = int(input('请输入汉诺塔的层数：')) hanoi(n,'X','Y','Z')

内置函数

常用数学运算函数

abs（）求绝对值round（）对浮点数进行近似取值 round（x[,n]) n表示保留几位小数pow（） 求幂；pow（n，m）表示n**mdivmod（）求商和余数max（）返回给点参数的最大值，参数可以是序列sum（）对系列进行求和 sum（iterable【，start】）eval（）动态执行表达式，，可以调用定义的函数 语法：eval（expression【，globals【，locals】】 参数：expression----表达式； globals----变量作用域，全局命名空间，如果被提供，则必须是一个字典对象； locals----变量作用域，局部命名空间，如果被提供，可以是任何映射对象。 eval('a+b+c',{'a':1,'b':3,'c':3}) 7

类型转换函数

bin（）转换二进制hex（）转换十六进制list（）将元组转换为列表tuple（）将列表转换为元组bytes（）转为字节数组 print(bytes('我喜欢python',encoding='utf-8'))

序列操作

all（）除了 0 空 false外都算true，全是true返回true 语法：all（iterable) 注意：空元组、空列表返回为trueany（）全部为flase返回false；如果有一个为true，则返回truesorted（）对所有可迭代的对象进行排序，返回的是一个新的list 如若要降序：后面加，reverse=Truesort() 修改的是原始对象 li=[2,3,4,22,3,5,6,7] li.sort() print(li) reverse（） 反向列表元素zip（）打包，返回元组组成的列表 s1=['a','b','c'] s2=['你','我','她'] print(list(zip(s1,s2))) [('a', '你'), ('b', '我'), ('c', '她')] def printBookInfo(): books = [] # 存储所有的图书信息 id = input('请输入编号：每个项以空格分隔') bookname = input('请输入书名：每个项以空格分隔') bookPos = input('请输入位置：每个项以空格分隔') idList = id.split(' ') namelist = bookname.split(' ') poslist = bookPos.split(' ') bookInfo = zip(idList, namelist, poslist) for bookItem in bookInfo: dictInfo = {'编号': bookItem[0], '书名': bookItem[1], '位置': bookItem[2]} books.append(dictInfo) pass for item in books: print(item) printBookInfo() enumerate（）给元素加索引 listObj=['a','v','c'] for item in enumerate(listObj): print(item) (0, 'a') (1, 'v') (2, 'c') listObj=['a','v','c'] for index,item in enumerate(listObj): print(index,item) 0 a 1 v 2 c

set集合

集合特点：不支持索引切片；无序且不重复的元素集合；用{} 空集合：set（）

add（）添加clear（）清空difference（）取差集 set1={1,2,2,4} set2={2,3,4} print(set1.difference(set2)) {1} intersection（）取交集 也可以用&union（）并集 也可以用 |pop（）拿出数据并删除；先排序拿出栈顶值discard（）指定移除update（）

内置函数作业

求三组连续自然数的和：求出1到10，20到30和35到45的三个和 def sumNature(m,n): ''' 求从m到n的连续自然数的和 :param m: 开始值 int :param n: 结束值 int :return: ''' return sum(range(m,n+1)) print(sumNature(1,10)) print(sumNature(20,30)) print(sumNature(35,45)) 100个和尚吃100个馒头，大和尚一人吃三个馒头，小和尚三人吃1个馒头。请问大小和尚各多少人？ def PersonCount(): ''' 计算各有多少个和尚 假设大和尚a，小和尚100-a :return: ''' for a in range(1,101): if a*3+(100-a)*(1/3)==100: return (a,100-a) rs=PersonCount() print('大和尚有{}人 小和尚{}人'.format(rs[0],rs[1])) 大和尚有25人 小和尚75人 指定一个列表，列表里含有唯一一个出现过一次的数字，写程序找出这个“独一无二”的数字。 li=[1,3,4,3,3,5,2,4,2,5,2,1,9] set1=set(li) for i in set1: li.remove(i) pass set2=set(li) #set2中为原来li中有重复的数字集合 for i in set1: #set1数据全部去重后形成的集合 if i not in set2: print(i)

面向对象

面向对象介绍

面向过程：根据业务逻辑从上到下写代码函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可面向对象编程：将数据与函数绑定到一起，进行封装，这样能够更快速的开发程序，减少了重复代码的重写过程。oop【object oriented programming】面向对象：关注的是设计思维，谁来做 面向过程关注：怎么做

类和对象

类：模板，模板可以包含多个函数【类名、属性、行为】 类是具有一组相同或相似属性和方法的一系列对象的集合对象：根据模板创建的实例，通过实例对象可以执行类中的函数

定义类和对象

结构 class 类名: 属性 方法 例子 class Person: ''' 对应人的特征 ''' name = '郑学鸿' age = 22 ''' 对应人的行为 ''' def eat(self): print('大口吃饭') pass def run(self): print('飞快的跑') # 创建对象【类的实例化】 # 对象名 = 类名（） zxh=Person() zxh.eat() #调用函数 zxh.run() print('{}的年龄是：{}'.format(zxh.name,zxh.age)) 大口吃饭 飞快的跑 郑学鸿的年龄是：22

实例方法与属性

实例方法：在类的内部，使用def关键字可以定义一个实例方法，与一般函数定义不同，类方法必须包含参数self【名字标识可以是其他的，但是这个位置必须占用】，且为第一个参数属性：类里面定义的变量。 定义在类里面，方法外面-------类属性 定义在方法里面使用self引用–实例属性 def __init__(self): self.name='郑学鸿'

_init_方法

class People: def __init__(self): self.name='小倩' self.sex='女生' self.age=20 def eat(self): print('喜欢吃榴莲') xq=People() # 也可以在此修改 print(xq.name,xq.sex,xq.age) 小倩 女生 20

init传递参数

class People: def __init__(self,name,sex,age): self.name=name self.sex=sex self.age=age def eat(self): print('喜欢吃榴莲') xq=People('zxh','man',22) print(xq.name,xq.sex,xq.age) zxh man 22

总结

init是python自带的内置函数，两边用双下划线抱起来【魔术方法】是一个初始化的方法。用来定义实例属性和初始化数据的，在创建对象的时候自动调用，不用手动去调用利用传参的机制可以让我们定义功能更加强大并且方便的类

self

self和对象指向同一个内存地址，可以认为self就是对象的引用

self只有在类中定义实例方法的时候才有意义，在调用的时候不必传入相应的参数，而是由解释器自动的去指向self的名称是可以更改的，可以定义成其他的名字，只是约定俗成的定义成selfself指的是类实例对象本身

魔术方法

init：初始化一个类，在创建实例对象为其复制的时候使用str：在将对象转换成字符串str测试的时候，打印对象的信息new：创建并返回一个实例对象，调用了一次就会得到一个对象class：获得已知对象的类del：对象在程序运行结束后进行对象销毁时调用这个方法，来释放资源。