小甲鱼python学习摘要（一）

仅作小甲鱼python学习记录使用

元组

不可更改 （与列表相比较）

• 创建和访问一个元组

  对元组而言，大部分使用小括号（列表中括号）

   >>> tuple1 = (1, 2 , 3, 4 ,5 ,6)
   >>> tuple1
   (1, 2, 3, 4, 5, 6)
   >>> tuple1[1]
   2
   >>> tuple1[5:]
   (6,)
   >>> tuple1[:5]
   （1, 2, 3, 4, 5)
   >>> tuple2 = tuple1[:]
   >>> tuple2
   (1, 2, 3, 4, 5, 6)        #拷贝
  

  注：小括号不是关键，逗号才是
  temp(1)—int
  temp(1,)----tuple
  对元组而言，乘号是重复操作符

• 更新和删除一个元组
  “ 切片 ”

temp = temp[:x] + (‘内容’)+temp[x:]

字符串内置方法

• 切片 同样适用于字符串

• （选自菜鸟教程）
  

字符串格式化

python中format函数用于字符串的格式化
用 {x} 表示replacement的字段（x可以是关键字参数，位置参数等）
例如：

 		  {0} 优快云 {1} format("www" , "net")
 		  {a} 优快云 {b} format(a="www" , b="net")  
 		  {0} 优快云 {b} format("www" , b="net") 

注：若同时使用关键字参数与位置参数时，则位置参数应放在关键字之前.
输出{}避免被作为参数符号

{{0}}.format("xxx")

用冒号作为字符串格式化的位置

 '{0:.1f}{1}'.format(27.658,'GB')

python数字格式化（截自菜鸟教程）

python的字符串格式化符号

python格式化操作符辅助指令

• 列表，元组和字符串的共同点
  都可以通过索引得到每一个元素
  默认索引值从0开始
  可以通过分片的方法得到一个范围内的元素的集合
  有很多共同的操作符（重复操作符，拼接操作符，成员关系操作符）

序列

list（）:把一个可迭代对象转换为列表
tuple([interable]):把一个可迭代对象转换为元组
str(obj) :把obj对象转换为字符串
max() :返回序列/参数集合中的最大值
min() :返回序列/参数集合中的最小值
sum(iterable[ , sum = 0]): 返回序列iterable和可选参数start的总和
如：

        >>> numbers = [2,45,65,1]
	>>> sum(numbers)
	113
	>> sum(numbers,88)
	201

sorted(numbers):将列表正向排序
list(reversed(numbers)):将列表直接倒序（并不做排序，同时也并没有改变原来的numbers)
enumerate():枚举，生成由每个元素组成的index值和item值组成的元组（返回对象）
zip():返回由各个参数的序列组成的元组（返回对象）
如：

>>> a = (4, 5, 8, 3, 44 ,5)
>>> b = (5, 3, 45)
>>> zip(a,b)
<zip object at 0x000001B945D6E5C8>
>>> list(zip(a,b))
[(4, 5), (5, 3), (8, 45)]

函数

def 函数名(参数)

• 形参与实参

  def MyFirstFunction(name)：

  函数定义过程中的参数（此处为name）叫做形参，表示一个参数位置

  MyFirstFunction(name)

  此处的name叫做实参，因为代表具体的参数值。
  注：若在使用收集参数的同还想使用其他参数，最好使用默认参数

• 函数返回值
  1，函数返回值可以是任意的数据类型
  2，如果有返回值：必须要用变量接收才会有效果
  3，函数可以没有返回值,默认返回给None
  函数的返回值为None有三种情况
  1.不写返回值
  2.只写一个return
  3.return None （几乎不用）

• 局部变量与全局变量
  （与其他编程语言大致类似，因此略）
  用global修改全局变量

• 函数的闭包
  如果在一个内部函数里，对外部作用域（但不是在全局作用域进行引用）那内部函数就被认为是闭包。
  注明：若要在内部函数修改外部函数变量，可以使用nonlocal声明该变量。

lambda函数表达式

python写一些执行脚本时，使用lambda就可以省下定义函数过程
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda表达式是起到一个函数速写的作用。允许在代码内嵌入一个函数的定义
对于抽象并且只需要调用一两次的函数而言使用lambda表达式不需要考虑命名问题

两个常用的BIF

• filter（）

  list(filter(lambda x : x % 2,range(10)))
  （筛选出 10 以内的奇数）

• map()
  一般用作映射来解释
  两个内置参数，一个函数一个可迭代的序列
  功能：将序列的每一个元素作为函数的参数进行运算加工，直到所有元素加工完毕，返回所有加工后的元素构成的新序列

递归

本质是出栈与进栈
一个例子，求某数的阶乘
非递归算法

def factorial(n):
    result = n
    for i in range(1,n):
        result *=i-1

    return result

number = int(input("int"))
result = factorial(number)
print("%d 的阶乘是 ：%d " % (number,result))

递归算法

def factorial(n):#阶乘求法二，递归
    if n == 1:
        return 1
    else :
        return n*factorial( n-1 )
number = int(input("int"))
result = factorial(number)
print("%d 的阶乘是 ：%d " % (number,result))

• 斐波拉契数列的迭代实现

def fun(n):#递归
    n1 = 1
    n2 = 1
    n3 = 1

    if n < 1:
        print("wrong")
        return -1

    while (n - 2) >0 :
        n3 = n2 + n1
        n1 = n2
        n2 = n3
        n -= 1
    return n3

result = fun(20)
if result != -1:
    print('the number is' % result)

迭代求和

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)

result = fab(20)
if result != -1:
    print("求和为%d"  % result )

• 递归实现汉诺塔

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)
        hanoi(n-1,y,x,z)

n = int(input("请输入汉诺塔的层数"))
hanoi(n,'x' , 'y' ,'z')

• 内置字典dict（映射
  使用键-值（key-value）存储，具有极快的查找速度

dict.fromkeys(seq[, val])
创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值

• set 集合
  确定性，互异性，唯一性
  创建：一种是直接把一堆元素用花括号括起来，一种是使用set工厂函数
  用集合可以去除列表中重复元素