python笔记第五章

序列：在python中相当于若干元素的一个容器
分类：列表:list[],元组:(),字符串，Unicode字符串，buffer对象，xrange/range对象
通用操作：
索引：按下标取值
分片：s[i:j:k]

l=[1,2,3,4,5,6,7,8,9]
print(l[1:9:1])
print(l[1:9:2])
print(l[1:9:3])

[2, 3, 4, 5, 6, 7, 8, 9]
[2, 4, 6, 8]
[2, 5, 8]
加：连接两个序列

l=[1,2,3,4,5,6,7,8,9]
s=['a','b','c']
print(l+s)

[1, 2, 3, 4, 5, 6, 7, 8, 9, ‘a’, ‘b’, ‘c’]
乘：重复连接同意序列

s=['a','b','c']
print(s*3)

True
计算序列长度 len(x)

l=[1,2,3,4,5,6,7,8,9]
print(len(l)) #9

找出最大元素和最小元素

l=[1,2,3,4,5,6,7,8,9]
print(max(l))#9
print(min(l))#1

l=[1,2,3,4,5,6,7,8,9]
print(l.index(2,1,4))#1  2：要查找的数   1：起始查找的位置  4：终止查找的位置

l=[1,2,2,2,2,6,7,8,9]
print(l.count(2))#4  计数2在l中出现的次数

字符串：
数字与字符串之间的相互转化
str(a) #数字转化为字符串
int() float()#字符串转化为数字
格式化生成字符串

n,f,s=62,5.03,'string'
print('n=%d,f=%f,s=%s'%(n,f,s))

n=62,f=5.030000,s=string
字符串操作函数：
字串查找与替换：str.find(s) str.rfind(s) str.replace(old,new)
查找子串的位置：str.index(s)
裁掉特定的字符的函数：str.lstrip([chars]) str.rstrip([chars]) str.strip([chars])
 

s="www.example.com"
print(s.rstrip("cmowz"))
print(s.lstrip("cmowz"))
print(s.strip("cmowz"))

www.example.
.example.com
.example.
分割字串：str.split(sep)

[‘www’, ‘example’, ‘com’]
大写字母转小写：

小写字母转大写：

s="abcdEFD"
print(s.upper())#ABCDEFD

• 函数的理解与定义
• 函数的使用及调用过程
• 函数的参数传递
• 函数的返回值
• 局部变量和全局变量

5.1.1 函数的理解与定义
函数是一段代码的表示

   def <函数名> (<参数(0个或多个)>) :
    <函数体>
    return <返回值>

例：计算 n！

ef fact(n) :
	s = 1
	for i in range(1, n+1):
		s *= i
	return s

5.1.2 函数的使用及调用过程

调用时要给出实际参数
实际参数替换定义中的参数
函数调用后得到返回值

例：计算 10！

def fact(n) :
	s = 1
	for i in range(1, n+1):
		s *= i
	return s
	
a = fact( 10 )
print(a)

3628800

函数的参数传递

• 无参数传递
  函数可以有参数，也可以没有，但必须保留括号

  def <函数名>() :
    <函数体>
    return <返回值>

• 可选参数传递
  函数定义时可以为某些参数指定默认值，构成可选参数

 def <函数名>(<非可选参数>, <可选参数>) :
   <函数体>
  return <返回值>

例：计算 n！// m

def fact(n, m=1) :
	s = 1
		for i in range(1, n+1):
			s *= i
	return s//m

>>> fact(10)
3628800
>>> fact(10,5)
725760

• 可变参数传递
  函数定义时可以设计可变数量参数，既不确定参数总数量

 def <函数名>(<参数>, *b ) :
   <函数体>
   return <返回值>

例：计算 n！乘数

def fact(n, *b) :
	s = 1
	for i in range(1, n+1):
		s *= i
	for item in b:
		s *= item
	return s
	
>>> fact(10,3)
10886400
>>> fact(10,3,5,8)
435456000

参数传递的两种方式
函数调用时，参数可以按照位置或名称方式传递

def fact(n, m=1) :
	s = 1
	for i in range(1, n+1):
		s *= i
	return s//m

>>> fact( 10,5 )
725760
>>> fact( m=5,n=10 )
725760

5.1.4 函数的返回值
函数调用时，参数可以按照位置或名称方式传递

def fact(n, m=1) :
	s = 1
	for i in range(1, n+1):
		s *= i
	return s//m, n, m

>>> fact(10,5)
(725760, 10, 5)

>>> a,b,c = fact(10,5)
>>> print(a,b,c)
725760 10 5

5.1.5 局部变量和全局变量

n, s = 10, 100				# n和s是全局变量
def fact(n) :
s = 1						# fact()函数中的n和s是局部变量
for i in range(1, n+1):
s *= i
return s
print(fact(n), s)			# n和s是全局变量

运行结果
>>>3628800 100
1
2
3
4
5
6
7
8
9
10

规则1: 局部变量和全局变量是不同变量

局部变量是函数内部的占位符，与全局变量可能重名但不同
函数运算结束后，局部变量被释放
可以使用global保留字在函数内部使用全局变量

n, s = 10, 100
def fact(n) :
global s				# fact()函数中使用global保留字声明,此处s是全局变量s
for i in range(1, n+1):
s *= i
return s				# 此处s指全局变量s
print(fact(n), s)		# 此处全局变量s被函数修改

运行结果
>>>362880000 362880000

ls = ["F", "f"]
def func(a) :
	ls = []					# 此处ls是列表类型，真实创建 ls是局部变量
	ls.append(a)
	return
func("C")					# 局部变量ls被修改
print(ls)

运行结果
>>>['F', 'f']

5.3 代码复用与函数递归

• 代码复用与模块化设计
• 函数递归的理解
• 函数递归的调用过程
• 函数递归实例解析

5.3.1 代码复用与模块化设计

• 函数 和 对象 是代码复用的两种主要形式
  函数：将代码命名 在代码层面建立了初步抽象
  对象：属性和方法 < a >.< b> 和 < a >.< b >() 在函数之上再次组织进行抽象

• 模块化设计———分而治之
  通过函数或对象封装将程序划分为模块及模块间的表达
  具体包括：主程序、子程序和子程序间关系
  分而治之：一种分而治之、分层抽象、体系化的设计思想

5.3.2 函数递归的理解

• 递归的定义
  函数定义中调用函数自身的方式
  𝑛! = 1       𝑛 = 0
    = 𝑛 (𝑛 − 1 )！  𝑜𝑡ℎ𝑒𝑟𝑤𝑖𝑠𝑒

• 两个关键特征
  链条：计算过程存在递归链条
  基例：存在一个或多个不需要再次递归的基例

5.3.3 递归的调用过程

def fact(n): 
	if n == 0 : 
		return 1 
	else : 
		return n * fact(n-1)

斐波那契数列
  = 1       n = 1
F(n) = 1       n = 1
   = F(n-1) + F(n-2) n = 2

def f(n): 
	if n == 1 or n == 2 : 
		return 1 
	else : 
		return f(n-1) + f(n-2)

5.4 PyInstaller库的使用

5.4.1 PyInstaller库概述

将.py源代码转换成无需源代码的可执行文件

PyInstaller库是第三方库

官方网站：http://www.pyinstaller.org
第三方库：使用前需要额外安装
安装第三方库需要使用pip工具