python小笔记

python小笔记

个人python小笔记

---

---

前言

因为之前都用matlab编程，很久没有写过python了，语法有点的忘记了，所以做个python小笔记捡起来。。。

---

strip()

  strip()方法用于移除字符串头尾指定的字符(默认为空格或换行符号)或字符序列。
  注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。
  用法:

str.strip([char])

例子：

s1='a123a'
s2=s1.strip('a')   #只能删除开头或是结尾
print(s2)          #s2: 123 

split()

描述
  split()方法通过指定分隔符对字符串进行切片，如果参数num有指定值，则分割num+1个子字符串
 
语法

str.split(str="",num=string.count(str)).

参数
str–分隔符，默认为空字符，包含空格、换行(\n)、制表符(\t)等。
num–分割次数。默认为-1,即分割所有。
 
返回值
返回分割后的字符串。
 
实例

txt="Line1-abcdef \nLine2-abc \nLine4-abcd"
txt.split()

output:

['Line1-abcdef', 'Line2-abc', 'Line4-abcd']

map()

描述
  map()方法是python内置方法(不用导包)，第一个参数function以参数序列中的每一个元素调用function函数，返回包含每次function函数返回值的新列表。
 
语法

map(function,iterable,...)

参数

function–函数
iterable–一个或者多个序列

 
返回值
python3返回迭代器
 
实例

def square(x) :         # 计算平方数
...     return x ** 2
list(map(square, [1,2,3,4,5]))   # 使用 list() 转换为列表

output:

[1, 4, 9, 16, 25]

字典

   字典是一种可变容器模型，可存储任意类型对象
字典的每个键值key=>value对冒号(:)分割，每个键值对之间用逗号(,)分割，整个字典包括在花括号( {} )中，格式如下：

d={key1:value1,key2:value2}

键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
一个简单的字典实例：

dict1={'Alice':'234','Beth':'902','Cecil':'3258'}

访问字典里的值
   访问字典值用字典名称接上方括号里面的键值访问(dict1[‘Alice’])

dict1 = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
print "dict1['Name']: ", dict1['Name']

output:

Zara

修改字典
   向字典添加新内容的方法是增加新的键值/值对，实例如下：

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
 
dict['Age'] = 8              # 更新
dict['School'] = "RUNOOB"    # 添加

删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。
显示删除一个字典用del命令，如下实例：

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
del dict['Name']  # 删除键是'Name'的条目
dict.clear()      # 清空字典所有条目
del dict          # 删除字典

字典键的特性
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
2）键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行

if条件判断

  (一行)if 简单条件判断

c=[]
d=c if len(c)!=0 else 'c是一个空列表'
print(d)
>>>c是一个空列表

for循环

   Python for循环可以遍历任何可迭代对象，如一个列表或者一个字符。
for循环的一般格式如下：

for <variable> in <sequence>:
    <statements>
else:
    <statements>

实例

languages = ["C", "C++", "Perl", "Python"] 
for x in languages:
...print (x)
... 
C
C++
Perl
Python

range()函数
  如果需要遍历数字序列，可以使用内置range()函数。他会生成数列

for i in range(5):
...print(i)
...
0
1
2
3
4

也可以使用range指定区间的值

for i in range(5,9) :
	print(i)
5
6
7
8

也可以使range以指定数字开始并指定不同步长(甚至可以是负数)
(第三个参数为步长)

for i in range(0, 10, 3) :
	print(i)
0
3
6
9

结合range()和len()函数可以遍历一个序列的索引

a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
for i in range(len(a)):
...print(i, a[i])
... 
0 Google
1 Baidu
2 Runoob
3 Taobao
4 QQ

还可以使用range()函数来创建一个列表

list(range(5))
[0, 1, 2, 3, 4]

break 与 continue

注意
   for循环的游标不会被循环内部改变

for i in range(5):
    print(i)
    i=i+1
0
1
2
3
4

for循环递减
  用range(start,stop[,step])实现循环递减计数

for i in range(3,-1,-1):
	print(i)
>>>3
>>>2
>>>1
>>>0

python枚举

  python 枚举通过enumerate()函数实现。enumerate()函数用于将一个可遍历的数据对象(入列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在for循环中。
语法 enumerate(sequence,[start=0])
  参数 squence:一个序列、迭代器或其它支持迭代的对象
  参数 start:下标起始位置

例子

seasons=['Sping','Summer','Fall','Winner']
list(enumerate(seasons))
>>>[(0,'Sping'),(1,'Summer'),(2,'Fall'),(3,'Winner')]

i=0
seq=['one','two','three']
for i,element in enumerate(seq):
  print(i,element)

递归

	递归中使用@lru_cache(None)来记录缓存当作备忘录。

例子(编辑距离)：

  @lru_cache(None)
  def dp(i,j):                #dp(i,j)返回s1[0...i]和s2[0...j]的最小编辑距离
      if i==-1: return j+1    #basecaes,其中一个字符串已经匹配结束
      if j==-1: return i+1
      ans=0
      if word1[i]==word2[j]:  #相等，进入下一个匹配
          ans=dp(i-1,j-1)
      else:                   #不相等，从插入、删除、替换三种操作中选择一种
          ans=min(dp(i,j-1), dp(i-1,j), dp(i-1,j-1))+1
      return ans 

  return dp(len(word1)-1,len(word2)-1)

第一行中的@lru_cache(None)相当于备忘录中的三行代码

  def dp(i,j):                #dp(i,j)返回s1[0...i]和s2[0...j]的最小编辑距离
      if i==-1: return j+1    #basecaes,其中一个字符串已经匹配结束
      if j==-1: return i+1
      ans=0
      if (i,j) in memo:return memo[(i,j)]
      if word1[i]==word2[j]:  #相等，进入下一个匹配
          ans=dp(i-1,j-1)
      else:                   #不相等，从插入、删除、替换三种操作中选择一种
          ans=min(dp(i,j-1), dp(i-1,j), dp(i-1,j-1))+1
      memo[(i,j)]=ans 
      return ans 
      
  memo={}
  return dp(len(word1)-1,len(word2)-1)

  在记忆化递归中调用cache_clear()清除缓存，能够加速程序运行。
例子：

  @lru_cache(None)
  def dp(s,e,m):                 #dp(s,e,m)返回在nums[s...e]执行m步操作的最大分数
      if m==n:return 0           #baseline,执行恰好m步操作                   
      ans=max(multipliers[m]*nums[s]+dp(s+1,e,m+1),multipliers[m]*nums[e]+dp(s,e-1,m+1))   #每次可以选择开头s或者结尾e的数
      return ans 

  n=len(multipliers)
  return dp(0,len(nums)-1,0)     #返回nums[0...结尾]从0步开始执行的最大分数

  调用cache_clear()清除缓存

  @lru_cache(None)
  def dp(s,e,m):                 #dp(s,e,m)返回在nums[s...e]执行m步操作的最大分数
      if m==n:return 0           #baseline,执行恰好m步操作                   
      ans=max(multipliers[m]*nums[s]+dp(s+1,e,m+1),multipliers[m]*nums[e]+dp(s,e-1,m+1))   #每次可以选择开头s或者结尾e的数
      return ans 

  n=len(multipliers)
  ans=dp(0,len(nums)-1,0)
  dp.cache_clear()               #调用cache_clear()清楚缓存
  return ans 

设置最大递归深度

import sys
sys.setrecursionlimit(最大递归深度值)

sorted()

  sorted()函数对所有可迭代对象进行排序操作。
sort与sorted的区别
  sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
  list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
语法

sorted(iterable, key=None, reverse=False)  

参数说明：
  iterable – 可迭代对象。
  key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

实例

sorted([5, 2, 3, 1, 4])
>>>[1, 2, 3, 4, 5]                      # 默认为升序

  也可以使用 list 的 list.sort() 方法。这个方法会修改原始的 list（返回值为None）。通常这个方法不如sorted()方便-如果你不需要原始的 list，list.sort()方法效率会稍微高一些。

a=[5,2,3,1,4]
a.sort()        #list的sort方法没有返回值
>>> a
[1,2,3,4,5]

  list.sort() 方法只为 list 定义。而 sorted() 函数可以接收任何的 iterable

sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})  #字典也能sort
>>>[1, 2, 3, 4, 5]

array = [{"age":20,"name":"a"},{"age":25,"name":"b"},{"age":10,"name":"c"}]
array = sorted(array,key=lambda x:x["age"])
print(array)
>>>[{'age': 10, 'name': 'c'}, {'age': 20, 'name': 'a'}, {'age': 25, 'name': 'b'}]

count()

描述
  count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
语法

str.count(sub, start= 0,end=len(string))

参数
  sub – 搜索的子字符串
  start – 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
  end – 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

返回值
  该方法返回子字符串在字符串中出现的次数。
实例

str = "this is string example....wow!!!";
 
sub = "i";
print "str.count(sub, 4, 40) : ", str.count(sub, 4, 40)
sub = "wow";
print "str.count(sub) : ", str.count(sub)

output

str.count(sub, 4, 40) :  2
str.count(sub) :  1

类型转换

位运算

  按位运算就是把数字看作二进制进行计算。

运算符	描述	规则
&	按位与 (全1得1)	(1&1)为1，(1&0) 、(0&1)、(0 & 0)为0
l	按位或(有1得1)	(1 l 0) 、(0 l 1) 、(1 l 1) 为1，(0 l 0)为0
^	异或运算(相异为1)	(1 ^ 0)、( 0 ^ 1 )为1，(0 ^ 0 )、( 1 ^ 1)为0
~	取反	~1为0， ~ 0 为1
<<	左移(低位变0)	a=15 (1111)2, a<<1 为 a=30(11110)2
>>	右移(高位变0)	a=15(1111)2, a>>1 为 a=7(0111)2

字符串

字符串运算符

  [:]截取字符串中的一部分，遵循左闭右开原则，str[0:2]是不包含第三个字符的
实例

a='HelloPython'
print(a[1])
>>>e
print(a[1:4])
>>>ell

字符串格式化函数(str.format)

  格式化字符串函数str.format()通过{}和：来代替%
实例：

"{} {}".format("hello","world")       #不设置指定位置，按默认顺序
>>>'hello world'
"{1} {0}".format("hello","world")     #设置指定位置
>>>'world hello'
"{1} {0} {1}".format("hello","world") #设置多个指定位置
>>>'world hello word'

实例(设置参数)：

print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
>>>网站名：菜鸟教程, 地址 www.runoob.com

site={"name":"菜鸟教程","url":"www.runoob.com"} #通过字典设置参数
print("网站名：{name},地址 {url}".format(**site))
>>>网站名：菜鸟教程, 地址 www.runoob.com

my_list=['菜鸟教程','www.runoob.com']          #通过列表索引设置参数
print("网站名：{0[0]},地址 {0[1]}".format(my_list))))
>>>网站名：菜鸟教程, 地址 www.runoob.com

列表

创建二维列表
语法
创建一个row*col的二维列表A

A=[[0]*col for _ in range(row)]

列表函数

列表方法

list.extend()

  extend()函数用于在列表末尾一次性追加另一个序列中的多个值。

语法

list.extend(seq)

实例

list1 = ['Google', 'Runoob', 'Taobao']
list2=list(range(5)) # 创建 0-4 的列表
list1.extend(list2)  # 扩展列表（不同数据类型）
>>>['Google', 'Runoob', 'Taobao', 0, 1, 2, 3, 4] 

list.index()

描述
  index() 函数用于从列表中找出某个值第一个匹配项的索引位置。
语法

list.index(x[,start[,end])

参数
  x-- 查找的对象。
  start-- 可选，查找的起始位置。
  end-- 可选，查找的结束位置。

返回值
  该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。

实例

list1 = ['Google', 'Runoob', 'Taobao']
list1.index('Taobao')
>>>2

list.reverse()

  list.reverse() 函数用于反向列表中的元素。

实例

list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
list1.reverse()
>>>['Baidu', 'Taobao', 'Runoob', 'Google']

列表多关键字排序

  可以利用sorted和lambda的组合进行多关键字排序
实例

l = [['a', 2], ['c', 1], ['d', 4], ['b', 2]]
sorted(l,key=lambda x:(x[1],x[0]), reverse=True) #按l的l[1]关键字先排序，后按l[0]关键字再排序
>>>[['d',4],['b',2],['a',2],['c',1]]

如果需要第二个关键词降序排序需要先判断第二个关键词类型，如果是数字那么可以直接加负号，如果不是数字可以先转ASCII码再排序。

l = [['a', 2], ['c', 1], ['d', 4], ['b', 2]]
sorted(l,key=lambda x:(x[1],-ord(x[0])), reverse=True) #按l的l[1]关键字先排序，后按l[0]关键字再排序
>>>[['d', 4], ['a', 2], ['b', 2], ['c', 1]]

集合(python3)

  集合(set)是一个无序的不重复序列。
  可以使用大括号{}或者set()函数创建集合，需要注意的是创建一个空集合必须用set()而不是{}，因为{}是用来创建一个空字典。

创建集合

parame={value01,value02,...}
#或则
s=set('bcaa')
>>>{'a', 'b', 'c'}   #无序不重复

集合运算

  交(&)、并(|)、差(-)

a = set('abracadabra')
b = set('alacazam')
a&b         #a交b
>>>{'a', 'c'}
a|b         #aUb
>>>{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
a-b         #差集
{'r', 'd', 'b'}

集合基本操作

  1.添加元素

s.add(x)
s.update(x)

  2.移除元素

s.remove(x)    #如果元素不存在，则会发生错误
s.discard(x)   #如果元素不存在，不会发生错误

  3.判断元素是否在集合中存在

x in s

堆模块

  堆(heap)是一种优先队列，能够以任意顺序添加对象，并随时找出/并删除最小的元素。
  python中可以通过 import heapq模块来实现堆
  heapq模块默认只支持小根堆，大根堆的实现可以添加数据的相反数

引入堆模块

import heapq     #其中,heap指示堆，q指示队列

堆操作

将元素压入堆中

heapq.heappush(heap,x)   #将元素x压入堆heap(列表)中

弹出最小元素

heapq.heappop(heap)    #从堆中弹出最小的元素