python知识点

#ipython的使用
## 帮助功能
？：Ipython的概述和简介
help(name)：查询指定名称的帮助
obj？：列出obj对象的详细信息
obj？？：列出更加详细信息

## 特殊变量
_ ：表示前一次的输出
__：倒数第二次输出
___：倒数第三次输出
_dh：目录历史
_oh：输出历史

## shell命令
!command 执行shell命令
!ls -l
!touch test.txt
files = !ls -l | grep py

## 魔术方法
使用%百分号开头,ipython内置的特殊方法
%alias定义一个系统的别名
alias ll ls -l
%timeit statement
-n 一个循环loop执行语句多少次
-r 循环执行多少次loop，取最好的结果
%%timeit setup_code
%cd 改变当前工作路径
%pwd显示当前工作目录
%ls 返回文件列表

# 封装与解构
## 封装：
将多个值使用逗号分割，组合在一起。本质上是返回一个元组，只是省掉了括号。
如：t1 = 1,2 #实际上将1和2封装成了元组
temp = a ,a = b,b = temp;等价于 ==>> a,b = b,a

## 解构：
把线性结构的元素解开，顺序赋给其他变量；左边接纳变量数要和右边解开的元素数要一致

*：变量名*收集后组成一个列表
_:丢弃变量

## 例题
取出lst中的数字4：
lst = [1,(2,3,4),5]
_,(*_,a),_ = lst
print(a)
环境变量JAVA_HOME = /usr/bin,返回变量名和路径：
1. name,path = “JAVA_HOME = /usr/bin”.split(‘=’)
print(name,path)
2. name,_,path = “JAVA_HOME = /usr/bin”.partition(“=”)
print(name,path)
3. 封装解构来设计冒泡排序：
lst = [1,9,8,5,6,7,4,3,2]
for i in range(len(lst)):
flag = False
for j in range(len(lst)-i-1):
if lst[j]>lst[j+1]:
lst[j],lst[j+1] = lst[j+1],lst[j]
flag = True
if not flag:
break
print(lst)

# 字典（dict）
## 字典的性质
key-value键值对的数据的集合。可变的、无序的、key不重复

## 字典定义及初始化
1. d = dict() 或者 d = {}
2. dict(**kwargs) 使用name = value 初始化一个字典
例如：dict(name = “www”) >>> {‘name’:’wkj’}
3. dict(iterable,**kwarg)使用可迭代对象name=value对构造字典，但是可迭代对象的元素必须是一个二元结构
例如：d = dict(((1,’a’),(2,’b’))) 或者 d = dict(([1,’a’],[2,’b’]))
4. dict(mapping,**kwarg) 使用一个字典构建另一个字典
5. d={‘a’:10,’b’:20,’c’:None,’d’:[123]}
6. 类方法dict.fromkeys(iterable,value)
例如：d = dict.fromkeys(range(5))
>>> {0:None,1:None,2:None,3:None,4:None}
d = dict.fromkeys(range(3),10)
>>> {0:10,1:10,2:10}

## 字典元素的访问
(1) d[key]:返回key对应的值value,若key不存在抛出KeyError异常
(2) get(key[,default])：返回key对应的值value，key不存在返回default，如果没有default返回None
(3) setdefault(key[,default]):返回key对应的值value；key不存在，添加kv对，value为default，并返回default，如果default没有，即为None
例如：d = {0:10,1:10,2:8}
>>> d.setfault(0) —> 10
>>> d.setfault(3,8) —> 8

## 字典增加和修改
d[key] = value 将key的对应的值修改为value，若不存在，即添加kv对
update([other]) ：
(1) 使用另一个字典对kv对更新本字典：d.update(d1)
(2) key不存在就添加，如果存在就覆盖
(3) 就地修改
d.update(red = 1) d.update(((‘red’,1),)) d.update({‘red’:1})

## 字典删除
(1) pop(key[,default])
key存在，移除它，返回value
key不存在，返回给定的default
default未设置，key不存在则抛出keyError异常
(2) popitem()
移除并返回一个任意的键值对
字典为empty，抛出KeyError异常
(3) clear()
清空字典
(4) del语句
del d1[“age”] del d1[1]

## 字典遍历
(1) 遍历key
for k in d:
print(k)
for k in d.keys():
print(k)
(2) 遍历value
for k in d:
print(d[k])
for k in d.keys():
print(d.get[k])
(3) 遍历item,即KV对
for item in d.items():
print(item) #返回元组
for k,v in d.items():
print(k,v) #返回kv对
for _,v in d.items():
print(v) #返回value

## 字典的key
字典里面的key和set中的key要求一致
可哈希才可以作为key
d = {1:0,2.0:3,”abc”:None,(‘hello’,’world’,’python’):”string”,b’abc’:’135′}

## defaultdict用法
from collections import defaultdict
d1 = {}
d2 = defaultdict(list)
for k in “abcde”:
for v in range(5):
if k not in d1.keys():
d1[k] = []
d1[k].append(v)
print(d1)
for k in ‘mnopq’:
for v in range(3):
d2[k].append(v)
print(d2)

## OrderedDict用法
有序字典可以记录元素插入的顺序，打印的时候也是按照这个顺序输出打印
from collections import OrderedDict
import random
d = {‘banana’: 3, ‘apple’: 4, ‘pear’: 1, ‘orange’: 2}
print(d)
keys = list(d.keys())
random.shuffle(keys)
print(keys)
od = OrderedDict()
for key in keys:
od[key] = d[key]
print(od)
print(od.keys())

# set集合
## set性质、定义、初始化
性质:可变的、无序的、不重复的元素的集合
定义：set() set(iterable)
s1 = set() s2 = set(range(5)) s5 = {3,4,5}

## set的元素
set的元素要求必须是可哈希的
目前不可hash的类list、set
元素不可以索引
set可迭代

## set增加与删除、成员运算符
s1.add()：增加一个元素，如果元素存在，则什么都不做
s1.update(*other)：合并其他元素到set集合，参数other必须是可迭代对象，就地修改
s1.remove() :从set中移除一个元素，元素不存在则抛出keyError
s1.discard() :set中移除一个元素，不存在，则不操作
s1.pop()：移除一个任意元素，空集返回KeyError异常
s1.clear()：移除所有
in和not in 可以判断元素是否在set中

## set和线性结构
线性结构的查询时间复杂度是O(n),而set、dict使用hash值做为key，时间复杂度为0(1)

# 集合
## 集合基本概念
全集，子集，超集，真子集，真超集
并集：多个集合合并部分
交集：多集合公共部分
差集：多集合出去公共部分

## 集合运算
并集： a | b a.union(b) a |= b （就地修改）
交集： a & b a.intersection(b) a &= b（就地修改）
差集： a – b a -= b
对称差集： a ^ b a ^= b 记作(A-B)U(B-A)

issubset(other) <= 判断是否是另一集合的子集
set1 < set2 判断是否真子集
issuperset(other) >= 判断是否是other超集
set1 > set2 判断set1是否是set2的真超集
isdisjoint(other) 判断当前集合与other有没有交集，没有交集返回True

# 简单选择排序
基础版：
list1 = [1,9,4,6,2,3,7,8,5]
length = len(list1)

for i in range(length):
maxindex = i
for j in range(i+1,length):
if list1[maxindex] < list1[j]:
maxindex = j
if i != maxindex:
list1[maxindex],list1[i] = list1[i],list1[maxindex]
print(list1)
优化版：
lst1 = [5,4,9,7,1,2,6,3,8]
length = len(lst1)

for i in range(length//2):
maxindex = i
minindex = -i-1
minorigin = minindex
for j in range(i+1,length-i):
if lst1[maxindex] < lst1[j]:
maxindex = j
if lst1[minindex] > lst1[-j-1]:
minindex = -j-1

if lst1[minindex] == lst1[maxindex]:
break
if i != maxindex:
lst1[i],lst1[maxindex] = lst1[maxindex],lst1[i]
if i == minindex or i ==length + minindex:
minindex = maxindex
if minorigin != minindex and lst1[minorigin] != lst1[minindex]:
lst1[minorigin],lst1[minindex] = lst1[minindex],lst1[minorigin]
print(lst1)

# 标准库datetime
datetime模块：对日期、时间、时间戳的处理
datetime类：
类方法：
today() 返回本地时区的datetime对象
now() 返回当前时间的datetime对象
ntcnow() 没有时区的当前时间
fromtimestamp(timestamp,tz = none),从一个时间戳返回一个datetime对象
datetime对象：
timestamp() 返回一个到微秒的时间戳
构造方法：datetime.datetime(2016,07,12,19,23,44,79066)
year month day hour minute second microsecond用对象取这些属性
weekday() isoweekday() 返回星期的天，前者0开始，后者1开始
date() time() replace() isocalendar()
日期格式化：
类方法strptime(date_string,format),返回datetime对象
对象方法strftime(format),返回字符串
字符串format函数格式化：
import datetime
dt = datetime.datetime.strptime(“21/11/06 16:30”, “%d/%m/%y %H:%M”)
print(dt.strftime(“%Y-%m-%d %H:%M:%S”))
print(“{0:%Y}/{0:%m}/{0:%d} {0:%H}::{0:%M}::{0:%S}”.format(dt))
timedelta对象：
构造方法：datetime.timedelta(days = 0,seconds = 0…)
year = datetime.timedelta(days = 365)
total_seconds():返回时间差的秒数

# 标准库time
time.sleep(seconds) 将调用线程挂起指定的秒数

# 列表解析 List Comprehension
语法：[返回值 for 元素 in 可迭代对象 if 条件] 它返回的是一个新的列表
优势：是一种语法糖，编译器会优化，提高了效率，简化了代码，增加了可读性
练习1.返回 1-10 平方的列表
[x**2 for x in range(1,11)]
练习2.返回lst = [1,4,9,16,2] 的相邻两项之和
[lst[i]+lst[i+1] for i in range(len(lst)-1)]
练习3.打印九九乘法表
[print(‘{}*{}={:<3}{}’.format(j,i,i*j,’\n’ if i == j else ”),end=””) for i in range(1,10) for j in range(1,i+1)]
练习4.依次生成前100个ID的列表，左边4位从1开始的整数，右边是10位随机小写的英文字母。例‘0001.abadicddws’
方法1 import random
[‘{:04}.{}’.format(i,”.join([chr(random.randint(97,122)) for j in range(10)])) for i in range(1,101)]

方法2 import string
[‘{:>04}.{}’.format(i,”.join(random.choice(string.ascii_lowercase) for _ in range(0,10))) for i in range(1,101)]

# 生成器表达式
语法：
-(返回值 for 元素 in 可迭代对象 if 条件)
-列表解析式由中括号[] 换成 小括号
-返回一个生成器
和列表解析式的区别：
-生成器按需计算(惰性求值、延迟计算)，需要的时候才计算值
-列表解析式是立即返回值
生成器：
-可迭代的对象
-迭代器
例如：
-g = (“{:04}”.format(i) for i in range(1,11))
-next(g)
与列表解析式的对比：
-生成器表达式延迟计算，列表解析式立即计算
内存占用
-生成器占用内存较少，二列表解析式占用内存多
计算时间：
-生成器的耗时非常短，列表解析式耗时长
-但是生成器本身并没有返回任何值，只返回了生成器对象
-列表解析式构造并返回了一个新的列表

# 集合解析式
语法：
– {返回值 for 元素 in 可迭代对象 if 条件}
– 列表解析式的中括号换成大括号{}
– 立即返回一个集合
用法：
– {(x,x+1) for x in range(10)}
– {[x] for x in range(10)} #错误，[x] 不可是不可hash的列表

# 字典解析式
语法：
– {返回值 for 元素 in 可迭代对象 if 条件}
– 使用key:value形式
– 立即返回一个字典
用法：
– {x:(x,x+1) for x in range(10)}
– {x:[x,x+1] for x in range(10)}
– {(x,):[x,x+1] for x in range(10)}
– {[x]:[x,x+1] for x in range(10)} # 错误 列表不可hash
– {chr(0x41+x):x**2 for x in range(10)}# 它只返回了3个元素，木桶原理，因为一直在向前覆盖