【笔记】Python学习（廖雪峰）笔记①——Python基础知识

Python 基础知识

字符串与编码

ASCII、Unicode、UTF-8

ASCII	Unicode	UTF-8
可表达内容少，1个字节	可表达内容丰富，2个字节 乱码消失，存储空间占用多，在存储和传输上不划算	“可变长编码”，常用英文字母1个字节，中文字符2个字节 可节省空间

Python字符串

ord() - 获取字符的整数表示

chr() - 将编码转换为对应的字符

b’ ’ - bytes类型的数据

​ byte -> str : decode()

​ str -> byte：encode()

len() - 计算str的字符数bytes的字节数

# -*- coding:utf-8 -*- 按照UTF-8编码读取源代码

#！/user/bin/env python3 告知Linux/OS X系统，该程序为python程序

格式化

1. 占位法

   'Hi, %s, you have $%d.' % ('Michael', 1000000)

   =>

   'Hi, Michael, you have $1000000.'

占位符	替换内容
%d	整数
%f	浮点数
%s	字符串
%x	十六进制整数

2. format()

   用传入的参数依次替换字符串内的占位符

3. f-string

   使用以 f 开头的字符串 f'a is {xxx:.2f}'

   { xxx ：.2f }用对应的变量 xxx 替换，.2f指定格式化参数（保留两位小数）

使用list和tuple

list（类似数组）

define : List = [1,2,3]

末尾追加 listA.append(str)

插入到指定位置 listA.insert(index,str)

删除末尾元素 listA.pop()

删除指定元素 listA.pop(index)

替换 直接赋值

tip:

1. list中的元素数据类型可以不同
2. list中的元素可以是另一个list（嵌套）

tuple （元组，有序列表）

define：t = (1,2,3)

Key：tuple一旦初始化就不能修改==>代码更安全

tip:

1. 定义tuple时，tuple的元素就必须被确定
2. 只有1个元素的tuple，需要在元素后增加 “ , ” 来与单独的数字区分开来
3. tuple的“不能修改”是指，tuple的每个元素指向永远不变

条件判断

if - elif - else

​ 自上而下判断，当某判断为True时，忽略剩下的 elif 和 else

循环

1. for … in …

2. range( num )——生成整数数列（0 ~ num-1）

3. while——条件满足时，不断循环

4. break——提前退出循环

5. continue——跳过当前循环，直接开始下一次循环

dict和set

dict

dict - dictionary ( ≈ map )，使用键值（key - value）存储

tip:

1. 初始化指定数据 or 通过key放入
2. 一个Key只能对应一个value
3. key不存在，dict报错
   • 通过 in 判断key是否存在
   • 通过 dict中的get() 方法，不存在则返回none or 指定value
4. 通过 pop(key) 的方法，删除key
5. dict内部存放顺序与key放入的顺序无关
6. dict的key必须是不可变对象（字符串、整数等不可变，list可变），通过key计算位置的算法成为哈希算法（Hash）

Dict（空间换时间）	List
查找和插入的速度极快，不会随着key的增加而变慢	查找和插入的时间随着元素的增加而增加
占用大量内存，内存浪费多	占用空间小，浪费内存少

set

一组key的集合，无需存储value；在set中，没有重复的key

创建——提供一个list作为输入集合，重复元素自动过滤，无序

添加—— add(key) 可重复添加，但结果不变

删除——remove(key)

操作——数学意义上的交集、并集

tip：不可以放入可变对象（因为如果无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”）

不变对象

对于不变对象，调用对象自身的任意方法，也不会改变对象自身的内容。

相反，这些方法会创建新的对象并返回，保证了不变对象本身永远是不可变的

对象不变，多任务环境下同时读取对象无需加锁

>>>a = 'abc'
>>>a.replace('a','A')
'Abc'
>>>a
'abc'

>>>a = 'abc'
>>>b = a.replace('a','A')
>>>b
'Abc'
#a.replace创建了一个新的对象给b，但a本身没有变化

函数

调用函数

​ 参数数量不对，参数类型错误——TypeError

数据类型转换：int()，str()，bool()，float()……

可以将函数名赋给变量，即起“别名”

定义函数

​ def 函数名(参数)：return

空函数

​ def nop():pass 什么都不做的空函数，pass可以用来做占位符

参数检查

​ 个数不对，python可以检查；参数类型不对，无法检查

​ 使用内置函数 isinstance() 进行数据类型检查

​ if not isinstance(x,(int,float))

参数返回

​ 可以多个值返回，在函数内部表现为返回一个tuple，在语法上，返回一个tuple可以省略括号，多个变量可以同时接收一个tuple，按位置赋给对应的值

参数

1. 位置参数

2. 默认参数：简化参数的调用

def power(x,n=2):
    s = 1
    while n > 0 :
        n = n - 1
        s = s * x
    return s

>>>power(5)
25
>>>power(5,3)
125

• 必选参数在前，默认参数灾后
• 变化大的参数在前，变化小的参数在后（即变化小的作为默认参数）
• 默认参数必须指向不变对象

3. 可变参数

• 允许传入0个/任意个参数

• 在函数调用时自动组装为一个tuple

• def function(*numbers)

• 在list/tuple前加 * ，可以将list/tuple的元素变成可变参数传进来

  def calc(*numbers):#传入可变参数
      pass
  >>>calc(1,2)
  >>>calc()
  nums = [1,2,3]
  >>>calc(*nums)#将list变为可变参数
  

4. 关键字参数

• 允许传入0个/任意个含参数名的参数

• 关键字参数在函数内部自动组装为一个dict

• def function(**keyword)

• 用于扩展函数功能

  def person(name,age,**kw):
      print('name:',name,'age:',age,'other:',kw)
      return
  #仅传入必选参数
  >>>person('Michel',30)
  name: Michael age: 30 other: {}
  #传入任意个数的关键字参数
  >>>person('Bob',35,city='Beijing')
  name: Bob age: 35 other: {'city': 'Beijing'}
  #传入一个组装好的dict
  >>>extra = {'city': 'Beijing', 'job': 'Engineer'}
  >>>person('Jack',24,**extra)
  name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}
  

5. 命名关键字参数

• 限制关键字参数的名字

• 使用特殊分隔符 * ， * 后面的参数被视为命名关键字参数

• def function(para1,para2,*,keypara1,keypara2)

• 如果没有可变参数，就必须加一个 * 作为特殊分隔符；如果缺少 * ，Python解释器将无法识别位置参数和命名关键字参数

• 命名关键字参数必须传入参数名

• 命名关键字参数可以有缺省值

  def person(name,age,*args,city,job):
      print(name,age,args,city,job)
  >>>person('Jack', 24, 'Beijing', 'Engineer')
  TypeError
  #将Jack和24传入到name和age,'Beiging'和'Engineer'一起传入了*args
  def person(name,age,*,city='Beijing',job):
      print(name,age,city,job)
  >>> person('Jack', 24, job='Engineer')
  Jack 24 Beijing Engineer
  

6. 参数组合

• 顺序：必选参数 - 默认参数 - 可变参数 - 命名关键字参数 - 关键字参数

  #必选参数(a,b),默认参数c,可变参数args,关键字参数kw
  def f1(a,b,c=0,*args,**kw):
      print
  >>>f1(1, 2, 3, 'a', 'b', x=99)
  a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
  
  #必选参数(a,b),默认参数c,命名关键字参数d,关键字参数kw
  def f2(a, b, c=0, *, d, **kw):
      print
  >>> f2(1, 2, d=99, ext=None)
  a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}
  
  #使用tuple和dict，调用函数f1
  >>> args = (1, 2, 3, 4)
  >>> kw = {'d': 99, 'x': '#'}
  >>> f1(*args,**kw)
  a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}
  
  #使用tuple和dict，调用函数f2
  >>> args = (1, 2, 3)
  >>> kw = {'d': 88, 'x': '#'}
  >>> f2(*args, **kw)
  a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}
  
  

• 不建议同时使用太多的组合，否则函数接口的可理解性很差

递归函数

优点：定义简单，逻辑清晰

尾递归：在函数返回时，调用自身本身，return语句不能包含表达式——防止栈溢出