day2和day3随堂笔记

学习网站：www.cnblogs.com/wupeiqi/articles/5115190.html

day2学习笔记

tuple,integer(整形),str不可变数据类型
list，dict可变数据类型，字典的key必须是不可变类型
sys.argv：是个列表，用于接收你输入的参数
比如：
test.py文件内容如下
import sys
print (sys.argv)
运行后
python python.py server
输出为 ['python.py','server']

dir查看类的所有属性
vars列出类的属性和属性对应的值

字符串str内部功能：
capitalize()：首字母大写
casefold()：大写变小写
center(长度，"填充，默认空格")：居中，括号中写入字符长度
count(某个字符串中的字符，起始位置，结束位置)：计算重复的次数
encode(gbk)：把utf-8的中文，转换为gbk格式
endswith(可选项（开始位置算，结束位置不算）)：查看以什么结尾，返回True or False
expandtabs()：把一个tab转换八个空格
find(起始位置，结束位置)：存在则返回index位置，否则返回-1
index()：返回位置，不存在报错
format()：拼接字符串
>>> a="1 {0} {1}"
>>> a.format("2","2")
'1 2 2'
>>> a="1 {name} {id}"
>>> a.format(name="2",id="2")
'1 2 2'
"".join()：用于字符串拼接
ljust(个数，填充物)：左对齐
rjust(个数，填充物)：右对齐
lower()：变小写
lstrip()：只去左边空格
rstrip()：只去右边空格
maketrans和translate：创建对应关系，进行替换
>>> a="abc"
>>> b="123"
>>> tran=str.maketrans(a,b)
>>> dd="abcdefabc"
>>> dd.translate(tran)
'123def123'
partition("分隔符")：分隔字符串
>>> a="alexissb"
>>> b=a.partition("is")
>>> print(b)
('alex', 'is', 'sb')
replace('s','b'，需要替换的个数)：替换
>>> print(a.replace('s','b'))
alexibbb
rfind()：从右往左找
rindex():从右往左找
split()：也有rsplit()
splitlines()：根据换行符，分割为列表
strip()：去掉前后空白
swapcase()：转换字符串中所有字母的大小写
startwith(),endwith()：
title()：把首字母大写
upper():变大写
zfill(位数)：右对齐，左面不够的用0填充

day2作业扩展知识点

匹配文件路径的方法：
当前路径下：
>>> print(os.path.abspath('python.exe'))
C:\Python34\python.exe
其他路径下：参考文献http://alanland.iteye.com/blog/612459
使用 os.walk 方便很多.这个方法返回的是一个三元tupple(dirpath, dirnames,

filenames),
其中第一个为起始路径，
第二个为起始路径下的文件夹,
第三个是起始路径下的文件.
dirpath是一个string，代表目录的路径,
dirnames是一个list，包含了dirpath下所有子目录的名字,
filenames是一个list，包含了非目录文件的名字.这些名字不包含路径信息,如果需要得到全

路径,需要使用 os.path.join(dirpath, name).

下面是可以看到 os.walk 方法返回的内容.
代码:
import os
for i in os.walk('d:'+os.sep+'StormMedia'):
    print (i)
('d:\\StormMedia', ['StormCache'], [])
('d:\\StormMedia\\StormCache', ['021F5E1B3A246AA57F747EF67EC63586329FA597'], [])
('d:\\StormMedia\\StormCache\\021F5E1B3A246AA57F747EF67EC63586329FA597', [],

['meta.cache'])

os.sep
首先，Python 是跨平台的。
在 Windows 上，文件的路径分割符号是 '\' ，在 Linux 上 是 ‘/’。
为了让你的代码在不同的平台上都能运行，那么你写路径的时候是写 ‘/’ 还是写 '\' 呢？
使用 os.sep 的话，你就不用去考虑这个了，os.sep 根据你所处的平台，自动地采用相应的

分割符号。
举例：
Linux下一个路径,  /usr/share/python，那么上面的 os.sep 就是 ‘/’
Windows下一个路径, C:\Users\Public\Desktop, 那么上面的 os.sep 就是 '\'。

显示当前路径：os.path.dirname(__file__)
显示绝对路径：os.path.abspath(__file__)
os.path.join.(os.path.dirname(__file__)，文件名)
os.path.dirname(os.path.abspath(__file__))
def f():
  print "ok"
dicts={1:f}
dicts.get(1)()  #用get，如果key不存在返回-1，尽量不出错
函数里声明全局变量：global x，应用于局部变量操作，局部变量未声明就进行赋值等操作，

会报错；不声明局部变量，可以用各种python函数执行全局变量。
函数从上往下看，如果前面有x=1，则后一句global x没有意义了
函数，类，模块：可以形成自己的作用域
循环中，是否写countinue，取决于你是否想要执行下面的并行或者非并行的代码
enumerate，可用于字符串，序列，索引用，不包括集合
函数中变量是否存在的查找过程：
局部变量---enclosing直接外围空间----全局变量----内建命名空间

day3学习笔记

列表list内部功能介绍：
append：末尾增加
clear：清空列表
copy：浅拷贝
count：计算重复值个数
extend：把列表，字符串，元祖扩展到列表中
index：索引
insert(位置，值)：插入到某个位置
pop：删除某一位置的值，默认最后一个值
remove：删除值，而不是位置
reverse：翻转列表
sort：从小到大排序

元祖tuple内部功能介绍：
与字符串相同，不能修改
count：
index：

字典dict内部功能介绍：
clear：
copy：浅拷贝，拷贝一层
get：取key对应值，不存在则默认返回None，也可以设置默认值
items，keys，values：items返回所有的k,v键值对，放在元祖为值得列表中
pop：需要给出key，删除对应键值对
popitem：随即删除一个键值对，不好用
setdefault(key，设置默认值)：增加一个key，默认值为None
update()：更新字典
字典例子：
方法一：
>>> a=set((11,22,33,44,55,66,77,88,99))
>>> b={}
>>> b["k1"]=[]
>>> b["k2"]=[]
>>> b
{'k1': [], 'k2': []}
>>> for i in a:
 if i <66:
  b["k1"].append(i)
 else:
  b["k2"].append(i)
方法二：判断k1或者k2是否是b的key，而不要定义字典b的格式
>>> for i in a:
 if i>60:
   if "k1" in b.keys():
     b["k1"].append(i)
   else:
     b["k1"]=[i]
 else:
   if "k2" in b.keys():
     b["k2"].append(i)
   else:
     b["k2"]=[i]
>>> print (b)
{'k2': [33, 33, 11, 44, 22, 55], 'k1': [66, 66, 99, 77, 88]}

import copy
深拷贝：
浅拷贝：
ascii码：8位表示一个字节，最多只能表示2**8=256字节(表示8位的二进制表示字符由256种

排列。。。)
unicode：国际通用编码，最少占用两个字节，占用空间大
utf-8：对unicode占用空间的优化，国际通用编码，包括中文和英文，中文用3字节，英文一

个字节
gbk：也是对unicode的一种优化，是gb2312扩容的标准，度用于中文，每个字符占用2个字节

集合set内部功能介绍：
不允许重复元素
add：添加值
clear：清空数据
copy：浅拷贝
difference：找出原集合与括号中不同的值，并生成一个新的集合，例如
set.difference([值，值，...])
difference_update：找出原集合中与括号内匹配的值，并删除原集合被匹配的值
set.symmetric_difference：两个集合所有值求差集，返回所有不同的值
intersection：取交集，生成一个新集合
intersection_update：取交集，并修改原集合
isdisjoint：如果没有交集，返回True
issubset：是否是子集
issuperset：是否是父集，自身是自身的父集
pop：随机删除值，可用变量获取删除的值，集合为空，则返回keyerror
remove：指定删除值，不返回删除值
set.symmetric_difference_update：差集，改变原集合
set.symmetric_difference：差集，生成一个新的集合
set.union：取并集，生成一个新的集合
set.update：更新原集合

collections模块系列：
计数器Counter(dict)：对字典类型的一个补充，计算每一个重复字符次数，返回为字典
>>> collections.Counter("dsfdsagasgs")
Counter({'s': 4, 'g': 2, 'd': 2, 'a': 2, 'f': 1})

Counter.most_common(取前几位)：从大到小取出重复次数前几位的
>>> a=collections.Counter("dsfdsagasgs")  #a为字典类型
>>> a.most_common(2)
[('s', 4), ('g', 2)]
>>> a
Counter({'s': 4, 'g': 2, 'd': 2, 'a': 2, 'f': 1})

elements：取出collections.Counter("dsfdsagasgs")的每一个值：d，s...
update：更新原有计数器
>>> a=collections.Counter([11,22,33,44])
>>> a
Counter({33: 1, 11: 1, 44: 1, 22: 1})
>>> a.update([11,22,33])
>>> a
Counter({33: 2, 11: 2, 22: 2, 44: 1})
subtract：删除计数次数，没有的值，从-1开始计
>>> a.subtract([11,22,33])
>>> a
Counter({33: 1, 11: 1, 44: 1, 22: 1})

有序字典collections.OrderedDict：
用列表来维护key
dic={k1:v1,...}
li=[k1,k2...]
for i in li:
  print (dic[i])
例如
>>> a=collections.OrderedDict()
>>> a
OrderedDict([(1, 1), (2, 2), (10, 12)])

popitem：删除最后一个，后进先出，内存的栈就是这种方式
pop：指定删除某一个，有返回值
move_to_end：把key放到最后
fromkeys：从一个key值列表，只会取key，创建新的字典，不给value则默认None
>>> a=[1,2,3]
>>> dic=dict.fromkeys(a,10)
>>> dic
{1: 10, 2: 10, 3: 10}
setdefault：不设置默认None
update：更新有序字典，没有的添加
clear：清空
copy：浅拷贝
get：取值
items，keys，values：同字典

 

默认字典collections.defaultdict内部功能介绍：
继承父类dict的功能
>>> dic=collections.defaultdict(list)
>>> dic[1].append(1234)
>>> dic
defaultdict(<class 'list'>, {1: [1234]})

可命名元祖collections.namedtuple内部功能介绍：
根据namedtuple可以创建一个包含tuple所有功能以及其他功能的类型
对新建立每个元祖内的值不需要index，而是用定义的名字就可以访问到
创建一个类，相当于defaultdict这个类
>>> t=collections.namedtuple('t',['name','id','age'])
>>> x=t('tiny',123,31)
>>> print(x.name,x.id,x.age)
tiny 123 31

双向队列collections.deque内部功能介绍：
单向队列，是先进先出
内存是后进先出，就像弹夹
append：向右添加
append：往左添加
clear：清空
count：计算某个元素出现的次数
copy：浅拷贝
extend：向右扩展列表
extendleft：向左扩展列表
insert：插入值，从左向右
pop：取数据，并删除
rotate(个数)：从右边末尾取对应个数，依次添加到开头，倒数第五个，第四个...
popleft：从左开始删除取值
reverse：翻转列表
remove：删除值

单向队列queue.Queue内部功能介绍：
>>> import queue
>>> t=queue.Queue()
qsize：计算队列元素个数
put：插入一条数据，值
get(位置)：取一条数据，值

深拷贝浅拷贝：
import copy
对于int和str：只有一层
copy.copy()：浅拷贝----内存地址指向一致
copy.deepcopy()：深拷贝----内存地址指向一致
=：赋值----内存地址指向一致

对于其他：包括元祖，字典，列表，包括多层
copy.copy()：浅拷贝----内存地址指向不一致，只拷贝第一层，只拷贝列表元祖字典等，但

是内部所对应的元素内存地址指向一致，并不会拷贝，python所做的优化
copy.deepcopy()：深拷贝----拷贝多层，包括内部元素内存地址，所有字典等包括内部元素

内存地址指向都不相同
=：赋值----内存地址指向一致
例如：
>>> n1={'k1':123,'k2':234,'k3':[1,2,3]}
>>> n2=n1
>>> import copy
>>> n3=copy.copy(n1)
>>> n4=copy.deepcopy(n1)
>>> print (id(n1),'\n',id(n2),'\n',id(n3),'\n',id(n4))
 43347400
 43347400
 43337328
 43346440
#浅拷贝只拷贝了字典那一层，列表作为第一层的值，内存地址一致，如果n3修改了，n1也会

修改
>>> print (id(n1['k3']),id(n3['k3'])) 
43339488 43339488
#深拷贝拷贝了所有层，k3对应的是列表，列表作为第一层的值，内存地址不一致，如果n4修

改了，不会影响n1
>>> print (id(n1['k3']),id(n4['k3']))
43339488 43906032
#指向最终str或者int，则python优化，指向内存地址一致
>>> print (id(n1['k3'][1]),id(n3['k3'][1]))
1814286816 1814286816
#指向最终str或者int，则python优化，指向内存地址一致
>>> print (id(n1['k3'][1]),id(n4['k3'][1]))
1814286816 1814286816

函数def：
函数的返回值：return
函数中不写return：
则函数也有默认返回值，是None
函数中return后面的代码不会执行，相当于循环中的break和continue
pycharm断点调试：
用debug模式执行程序，再用>箭头，会按步骤执行程序
形参：
定义函数时指定的参数，例如def f(形参)
默认参数：
例如def f(形参1，形参2=100)，可以只传一个实参，默认参数可以有多个，默认参数只能写

在末尾
实参：
函数定义后，赋值给f(参数)，叫做实参

发送邮件的例子：发送邮件.py

指定参数：
把实参指定给对应的形参
>>> def f(a,b=100,c=11):
 print(a,b,c)
>>> f(b=2,c=3,a=1)
1 2 3
动态参数：
一个*星号，可以把传入的实参转换为元祖，赋值给形参
>>> def f(*dd):
 print(dd)
>>> f(1,2,3)
(1, 2, 3)
两个**星号，可以把传入的实参转换为字典，赋值给形参
>>> def f(**dd):
 print(dd)
>>> f(a=1,b=2)
{'b': 2, 'a': 1}
可以同时用：格式必须前面一个*星，后面**星
>>> def f(*dd,**ff):
 print(dd,ff)
>>> f(1,2,3,a=1)
(1, 2, 3) {'a': 1}
指定动态参数：
传入实参时候在前面加上*或者**来指定，int类型不可以当列表的值或者字典的key
>>> def f(*a,**b):
 print(a,b)
>>> l=["1"]
>>> h={"d":2}
>>> f(*l,**h)
(('1',), {'d':2})

open文件文本操作：
r+：读写
w+：写读
a：追加
U：把\r\n自动转化为\n，与r或r+模式一同使用
rU，r+U
b：处理二进制文件，rb，wb，ab
close：关闭文件
fileno(self，*args，**kwargs)：文件描述符
flush(self，*args，**kwargs)：刷新文件内部缓冲区，把内存刷进硬盘
read(self，*args，**kwargs)：读取指针后指定字符数据，一个中文也是一个字符
readable：是否可读
readline：读取一行
f.seek(偏移量,选项)
     选项 =0 时， 表示将文件指针指向从文件头部到 "偏移量"字节处。
     选项 =1 时， 表示将文件指针指向从文件的当前位置，向后移动 "偏移量"字节。
     选项 =2 时， 表示将文件指针指向从文件的尾部，，向前移动 "偏移量"字节。
tell：显示指针位置，按字节计数，一个汉字占用三个字节
truncate：把指针后面的内容删除
write：写入内容
writeable：是否可写

字符串转换为序列：
imoprt json
json.loads(字符串)
>>> a='[1,2,3]'
>>> import json
>>> b=json.loads(a)
>>> b
[1, 2, 3]
>>> type(b)
<class 'list'>

部分常用内置函数：
abs：绝对值
all：传入的列表值都为真，返回True,否则返回False
None，''，空列表，空元祖，空字典
>>> all(['',1,2])
False
any：只要有真，返回True，否则返回False
bin：返回二进制，0b格式
bool：判断True or False
callable：判断变量是否可以被调用，返回True or False。可以用()来判断
chr：把数字转换为字符
ord：把字符转换为数字
random模块
import random
>>> random.randint(1,10)  #返回一个区间内的随机数
7
>>> random.randint(1,10)
4
dict：字典
dir：返回当前所有的变量，不返回变量值
>>> dir()
['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__',

'a', 'b', 'f', 'line', 'os', 'random', 're', 's']
divmod：返回元祖，(商,余数)
>>> divmod(100,23)
(4, 8)
enumerate：循环时候，可以加上序号，并且可以定义初始值
>>> a
[1, 2, 3, ]
>>> for i,j in enumerate(a,1):
 print (i,j)
1 1
2 2
3 3
eval：可对比如excel表取出的int运算公式字符串操作
>>> eval("8*4")
32
filter：把不满足函数条件的取出，即为False的返回并取出
>>> def f(x):
 if x>10:
  return True
 else:
  return False
>>> a=[1,2,100]
>>> n=filter(f,a)
>>> list(n)
[100]
map：map(函数，被操作对象)，返回操作结果  #注意：函数不要加()
float：把int和int字符串返回浮点型
help：查看模块的属性和函数的属性
globals：返回当前所有变量和其对应的值，以字典形式列出
hash：把内容非常庞大的字符串或者int，转换成hash值，节省内存占用空间
hex：转换为十六进制，0x格式
id：返回内存地址
input：2.7为raw_input，输出为字符串
int：整形
len：返回字符串，列表值的长度
list：列表
max：返回最大值
min：返回最小值
oct：返回八进制，0o格式
open：打开一个文件，默认不加参数为只读模式，r,r+,w,a比较常用
pow：幂运算
>>> pow(2,3)
8
print：打印
range：拿到一个区间，默认从0开始，结尾值不包括，可以加步进
reversed：翻转列表
>>> b
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(reversed(b))
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
round：四舍五入
>>> round(8.5)
8
>>> round(8.6)
9
set：集合，去重，无序
sorted：从小到大排序
str：字符串
sum：求和
>>> b
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> sum(b) #括号中必须为可迭代的对象iterable
45
tuple：元祖
type：显示变量等的类型
vars：返回当前所有的变量和值，以字典方式列出，与globals类似
zip：
>>> b
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> c=[1,2,3]
>>> list(zip(b,c)) #按照zip中的顺序返回
[(0, 1), (1, 2), (2, 3)]

 

追加补充内容：
一、输入汉字，用二进制表示
bin(ord("人")) #只能一个汉字
utf-8：三个字节==一个汉字
一个字节==8bit(位)
ord：把字符转换为ascii的十进制数字
s="武大郎"
for i in s:
 print(s)
3.4按照字符循环：为汉字
2.7按照字节循环：为乱码
字符串：str
字节：bytes
2.7里bytes==str，指的都是字节
3.4里bytes(字符,'utf-8')，把汉字字符串转换为三个字节，默认是三个由十六进制构成，但

循环每个字节默认返回的是十进制
str(字节,'utf-8')把字节转换为字符串
汉字转换>>三个字节>>二进制

二、文件处理补充
py2
f=open('文件','r')
data=f.read()
f.tell #按照字节进行操作
f.seek #按照字节进行操作
py3
f=open('文件','r')   #如果是'rb'，按照字节进行操作
data=f.read()
f.tell #按照字节进行操作
f.seek #按照字节进行操作

三、yield
例如：
range(10)：py3中，只有for循环时候才会在内存中创建，相当于py2的xrange
特性：冻结状态，下次从上一次yield地方继续执行
循环或者__next__()，可以取出yield值
例子：自建range
>>> def myrange(x):
 temp=0
 while True:
  yield temp
  temp+=1
  if temp == x:
   return
>>> ret=myrange(2)
>>> for i in ret:
 print(i)
0
1

四、装饰器
存在的意义，在不修改原函数的基础上，
做到：在原函数执行前，做一个操作
          在原函数执行后，做一个操作
装饰器：
1.至少是一个双层函数
2.装饰器函数的外层函数返回值，是内层函数的函数名
3.应用装饰器，在函数 @外层函数名
def outer(func):
 def inner():
  print(000)
  func()
  print(456)
 return inner 
@outer
def foo():
 print 123 
foo()

作业讲解：
with open('1','r') as read_,open('2','w') as write_:
 for line in read_:
  write_.write()
1.增加，已存在，pass，不存在，添加
2.继续读一行写一行
3.删除，匹配的删掉
4.查找：，line.startwith()

五、py2与py3，对于中文字符的处理,str与bytes的区别：

# -*- coding:utf-8 -*-

# py 2.7
"""
s = "武沛齐"
for item in s:
    print(item,ord(item), bin(ord(item)))
# 问题？为什么2.7的for不以字符的形式循环
# 如果，字符，想要看字节，需要转换成字节
# 字符串 str ，字节 bytes[无用py3做过度]
# 1、for，默认字节循环
# 2、bytes类型形同虚设
"""
"""
s = "武沛齐"
for item in s:
    # print(item)# 汉字=》三字节》二进制
    print(item, bytes(item, 'utf-8'))
    item_bytes = bytes(item, 'utf-8')
    for j in item_bytes:
        print(j,bin(j))
"""
# py3
# 1、bytes，用来获取字符串的字节表示
# 2、for循环，字符循环

s = "武沛齐"
# 将字符串转换成字节
s_bytes = bytes(s, 'utf-8')
print(s_bytes)
# 将字节转换成字符串
new_str = str(s_bytes, 'utf-8')
print(new_str)