python第三周学习个人总结(ipython使用,封装解构,set .dict,选择排序,解释器生成器等)

个人总结加深印象

一、ipython的使用

1、ipython python的一个解释器。

2、官网介绍,帮助文档。

3、看out。。- – –

4、?Ipython的概述和间接

Help(name)

查询指定名称的帮助。

Obj?列出obj对象的详细信息。

Obj??列出更加详细的信息。

5、特殊变量

_表示前一次输出

—表示倒数第二次输出。

——表示倒数第三次输出。

-Oh显示所有输出历史。

-dh 显示目录。

6、执行shell的命令。

调用shell能用的命令。

!command执行shell命令。

!ls-l

!touch test.txt

File=!ls -l |grep py

7、魔术方法。

使用%号开头,ipython %timeit时间函数。

使用%%号的开头。

%%js

使用%百分号开头的,IPython内置的特殊方法

%magic 格式

% 开头是line magic

%% 开头是 cell magic,notebook的cell

%alias 定义一个系统命令的别名

alias ll ls -l

%timeit statement

-n 一个循环loop执行语句多少次

-r 循环执行多少次loop,取最好的结果

%%timeit setup_code

code…..

8、魔术方法

%cd 改变当前工作目录,cd可以认为是%cd的链接。路径历史在_dh中查看

%pwd、pwd 显示当前工作目录

%ls 、ls 返回文件列表

注意:%pwd这种是魔术方法,是IPython的内部实现,和操作系统无关。而!pwd 就要依赖当前操

作系统的shell提供的命令执行,默认windows不支持pwd命令

%%js、%%javascript 在cell中运行js脚本

%%js

alert(‘a’ + 1)

二、封装和解构。

1、转变成为元组。

2、先算后面的,在算左边的。

3、封装,将多个值使用逗号分隔,组合在一起。。本质上,返回一个元组,只是省略了一个小括号。。t1=(1,2) t2=1,2封装成tuple。

4、解构,把线性结构的元素解开,并顺序的赋给其它变量。

lst=[3,5]

first,second=lst

print(first,second)

3 5

左边接纳的变量数要和右边解开的元素个数一致。带有*号的除外。 x,y=list((2,3))

list .tuple .string ,bytes ,bytearray.

x,y=”a”,”b”既有封装又有解构的表达式。

举例子:[a,b]=(1,2) a,*b=(1,2,3) a,b={1,2}

5、使用*变量名接受,但不能单独使用。 lst=list(range(1,50,2)) head,*mid,tail=lst

6、被*变量名收集后组成一个列表。

7、*变量名尽可能多或者是没有。

8、丢弃变量。_

是一个惯例,是不成文的规定。如果不关心一个变量,可以将其丢弃。_是合法的标示符,看到下划线就知道是被舍弃的变量。

9、总结。_这个变量本身无任何意义,没有任何可读性。

三、集set

1、set翻译为集合。

2、Collection翻译为集合类型,是一个大概念。

3、Set是可变的,无序的,不重复的,元素的集合.

4、空的大括号是字典,大括号里面有元素的称为set。

5、空的集合就是s=set()。 列表和bytes不能。

6、Set定义,初始化; ()括号里面加可迭代的对象。

s1=set()

s2=set(range(5))

s3={(1,2),3,’a’}

7、必须是可hash()的才能够作为列表。

8、Set的元素。Set的元素要求必须可以hash。目前不可以hash的类型有list、set。

1)元素不可以索引。

2)Set可以迭代。

9、Set增加。add(elem),如果元素存在什么都不做。 add(‘abc’) s.add(15)

10、Update(*others),合并其他元素到set中。可以写多个可迭代对象。 就地修改。update(‘bcd’)

11、元素移除。remove() discard()不管有没有都不会报出异常。。pop()

clear()移除所有元素清除。

12、set修改,查找。 要么删除,要么加入新的元素。K就是对值进行求hash,然后房间放东西,查找的时候直接去房间拿东西。

成员运算符。In和no int判断元素是否在set中。 效率比较低。

13、set成员运算符的比较。

list和set的比较。Set的效率比较高,原因是因为hash。

14、Set和线性结构。

线性结构的查询时间复杂度是O(n),即随着规模的增大而增加耗时。

Set dict等结构,内部使用hash作为key,时间复杂度可以做到O(1),查询时间和数据规模无关。

15、不可变类型,成为可哈希类型。(想要哈希的话就应该有明确的值)。 拿所给的值。列出散落值。

16、可hash的类型。

数值型int 。Float。Complex。

布尔值True Flase

字符串string,bytes

tuple

None

都是不可变类型,成为可哈希的类型,hashable。

17、集合

概念。

1)全集

所有元素的集合,例如实数集,所有实数组成的集合就是全集。

2)子集(subset)和超集(superset)

一个集合A所有的元素都在另一个集合B内,A是B的子集,B是A的超集。

3)真字集合真超集。

A是B的子集,且A不等于B,A就是B的真子集,B就是A的真超集。

4)并集,多个集合合并的结果。

5)交集,多个集合公共的部分。

6)差集,集合中除去和其它集合公共部分。

7)并集:将两个集合A和B的所有元素合并到一起,组成的集合称作集合A和集合B的并集。Union(*others) 返回和多个集合合并后的新的集合。

8)|运算符重载 等同于union。

9)Update(*others) 和多个集合合并,就地修改。

10)|=等同于update。

11)交集:集合A和集合B,由所有属于A且属于B的元素组成的集合。

Intersection(*others) 返回和多个元素的交集。

&等同于intersection

Intersection_update(*others) 获取和多个集合的交集,并就地修改。

&=等同于intersection_update.

12)集合运算 差集

集合A和集合B,由所有不属于A且不属于B的元素组成的集合。

Difference(*others) 返回和对个集合的差集。

– 等同于difference

Difference_update(*others)

获取和多个集合的差集并就地修改。

-=等同于 difference_update

13)对称差集 集合A和B,由所有不属于A和B的交集元素组成的集合,计做作(A-B)∪(B-A)

Symmetic_difference(other) 返回和另一个集合的差集。

Symmetric_difference_update(other)获取和另一个几个的差集并就地修改。

^等同于Symmetic_difference

^=等同于Symmetric_difference_update

14)集合运算。

Issubset(set)、<= 判断当前集合是否是另一个集合的子集。

Set1<set2 判断set1是否是set2的真子集。

Issuperset(other)、>= 判断当前集合是否是other的超集。

Set1>set2 判断set1是否是set的真超集。

Isdisjoint(other) 当前集合另一个集合没有交集。没有交集,返回True。

集合去重,做随机运算。

四、选择排序

  • 简单选择性排序。

简单选择排序,两两比较大小,找出极值,(极大值和极小值)被放置在固定位置的某一端。结果分为升序和降序。

简单选择排序总结:

需要数据的一轮轮比较,并在每一轮中发现极值。

没有办法知道当前轮是否已经达到排序要求,但是可以知道极值。

遍历次数1,。。。N-1之和n(n-1)/2

时间复杂程度O(n(**2))。

减少了交换次数,提高了效率,性能略好于冒泡法。

五、字典。dict

1)定义

Key-value键值对的数据的集合,可变的无序的,key不重复

2)初始化,定义.

d={} 空的

d=dict(a=1,b=2) {‘a’: 1, ‘b’: 2}

类方法。d=dict.fromkeys(range(5))

d=dict.fromkeys(range(5),0)

dict(**kwargs) 使用name=value对初始化一个字典

dict(iterable, **kwarg) 使用可迭代对象和name=value对构造字典,不过可迭代对象的元素必须是一个二元结构

d = dict(((1,’a’),(2,’b’))) 或者 d = dict(([1,’a’],[2,’b’]))

dict(mapping, **kwarg) 使用一个字典构建另一个字典

d = {‘a’:10, ‘b’:20, ‘c’:None, ‘d’:[1,2,3]}

3)字典元素的访问

d[key] 返回key对应的值。

key不存在抛出KeyError异常

get (key[,default]) d.get(6,2000)不会报错。 key 不存在返回缺省值。

返回key对应的值value

key不存在返回缺省值,如果没有设置缺省值就返回None

setdefault(key[,default])

setdefault(100,300)不存在的话创建,存在的话不改变。

返回key对应的值value

key不存在,添加kv对,value为default,并返回default,如果default没有设置,缺省为None

4)增加和修改。

d=[key]=100将key对应的值修改为value。创建后直接赋值。Key存在不变,不存在直接赋值。Key是唯一的,key的位置是随机的。

d[key] = value

将key对应的值修改为value

key不存在添加新的kv对

update([other]) -> None

使用另一个字典的kv对更新本字典

key不存在,就添加

key存在,覆盖已经存在的key对应的值

就地修改

d.update(red=1)

d.update(((‘red’,2),))

d.update({‘red’:3})

5)字典删除。

pop(key[,default])。弹出元素。pop(key)

popitem () 移除并返回一个任意的键值对。

返回的是二元组,,key和value对应的。

clear()清空字典。

6)字典删除del。

del实际上删除的是名称,而不是对象。本质上减少了一个对象的引用。

7)字典的遍历。 for i in dict 拿出所有的key。拿到的都是key值。

遍历k

for k in d.keys():for k in d:

 

print(k)print(k)

 

for key in d.keys():

print(key)

 

遍历value

for value in d.values():for k in d:

print(value)print(d.get(k))

 

 

for k in d:

print(d[k])for k in d.keys():

print(d.get(k))

 

遍历k,v对

for key,value in d.items():

print(key,value)

 

 

for k ,_ in d.items():

print(k)

 

for _,v in d.items():

print(v)

 

 

 

8)字典遍历的总结。

Keys,values,Items方法返回一个类似一个生成器的可迭代对象,不会把函数的返回值复制到内存中。

dictionary view对象。

字典的entry的动态的试图,字典变化,视图将反应出这些变化。

9)字典遍历和移除元素

移除字符串,str。

keys=[]

for k in keys:

d.pop(k)

print(k)

for 循环过程中是坚决不允许移除元素的。

10)字典的key

要求必须和set的元素要求一致,,

Key必须可hash,key是去重复的。

d = {1 : 0, 2.0 : 3, “abc” : None, (‘hello’, ‘world’, ‘python’) : “string”, b’abc’ : ‘135’}

{1: 0, 2.0: 3, b’abc’: ‘135’, ‘abc’: None, (‘hello’, ‘world’, ‘python’): ‘string’}

11)defaultdict

collections.defaultdict([default_factory[, …]])

collentions.default

import random

from collections import defaultdict

 

d=defaultdict(list)

for i in ‘abcdef’:

for i in range(random.randint(1,5)):

d[k].append(i)

print(d)

12)ordereddict有序的字典。

collections.OrderedDict([items])

key并不是按照加入的顺序排列,可以使用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())

 

有序字典可以记录元素插入的顺序,打印的时候也是按照这个顺序输出打印。

应用的用途:

假如使用字典记录了N个产品,这些产品使用ID由小到大加入到字典中

除了使用字典检索的遍历,有时候需要取出ID,但是希望是按照输入的顺序,因为输入顺序是有序的

否则还需要重新把遍历到的值排序.

六、解析式、生成器。

1、标准库datetime:datetime模块。datetime.now()

1)对日期,时间,时间戳的处理。

datetime类

类方法:today() 返回本地时区当前时间的datetime对象

now(tz=None) 返回当前时间的datetime对象,时间到微秒,如果tz为None,返回

和today()一样

utcnow() 没有时区的当前时间

fromtimestamp(timestamp, tz=None) 从一个时间戳返回一个datetime对象

datetime对象,timestamp()返回一个到微妙的时间戳。

时间戳:格林威治时间1970年1月1日0点到现在的秒数

2)datetime对象

构造方法 datetime.datetime(2016, 12, 6, 16, 29, 43, 79043)

year、month、day、hour、minute、second、microsecond,取datetime对象的年月日时

分秒及微秒

weekday() 返回星期的天,周一0,周日6

isoweekday() 返回星期的天,周一1,周日7

date() 返回日期date对象

time() 返回时间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对象

datetime2 = datetime1 + timedelta

datetime2 = datetime1 – timedelta

timedelta = datetime1 – datetime2

构造方法

datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0,

minutes=0, hours=0, weeks=0)

year = datetime.timedelta(days=365)

total_seconds() 返回时间差的总秒数

time

time.sleep(secs) 将调用线程挂起指定的秒数

2、列表解析式

1)b=[i for i in range(10)]

print(b)

使用[]括号,内部是for循环,if语句可以多选。

返回一个新的列表。

2)编译器会优化,不会因为简写而影响效率,反而因优化提高了效率。

减少工作量,减少出错。

简化代码,可读性增强。

3、生产器表达式。

1)(返回值 for元素 in 可迭代对象 if条件)

利用小括号。

返回一个生成器。

返回的是生成器对象.

2)和列表解析式的区别,表达式是按需计算(或称为惰性求值,延迟计算)需要的时候才会出现。 不会立即生成一个值。 迭代器是可迭代对象,但是可迭代对象但不一定是可迭代器。

列表解析式立即返回一个值。

3)生成器:可迭代对象,迭代器。

g=(i for i in range(5))

for i in g:

print(i)

4、生成器,可迭代对象,迭代器。

next迭代器查看。 next()包装的是不同的迭代器的数字。

1)next总结

延迟计算

返回迭代器,可以迭代

从前到后走完一遍后,不能回头

2)不添加next的总结

总结

立即计算

返回的不是迭代器,返回可迭代对象列表

从前到后走完一遍后,可以重新回头迭代.

it=(print(“{}”.format(i+1))for i in range(2))

first=next(it)

second=next(it)

val=first+second 此种情况不成立。

Print返回值是none。

成立的表达式:

it = (x for x in range(10) if x %2)

first=next(it)

second=next(it)

val=first+second

print(first,second)

5、生成器和列表解析式的对比。

1)计算方式:生成器表达式延迟计算,列表解析式立即计算。

2)内存占用:单从返回值来看,生成器表达式省内存,列表解析式返回新的列表。

生成器没有数据,内存占用极少,但是使用的时候,虽然一个个返回数据,但是使用的内存也不多。

列表解析式构造新的列表需要占用内存。

3)计算速度:计算时间来看,生成器耗时非常短,列表解析式耗时长。

但是生成器本身并没有任何返回值,只返回了一个生成器对象。

列表解析式构造并返回了一个新的列表。

6、集合解析式

{返回值 for 元素 in 可迭代对象,if} 立即返回一个对象。

使用一个大括号。

{(x,x+1)for x in range(10)}

7、字典解析式。

{K:v} 使用key,value值 立即返回一个字典。

8、总结

一般来说,多应用解析式,简短,高效。

迭代器和生成器是不同的对象,但都是可迭代对象。

七、习题练习

1、求杨辉三角第m行第k列的值

m=5
k=4
a=[]
for i in range(m):
pre=[1]
a.append(pre)
if i==0:
continue
for j in range(1,i):
pre.append(a[i-1][j-1]+a[i-1][j])
pre.append(1)
print(a)

2、# 打印矩阵
import copy
f1=[[1,2,3],[4,5,6],[7,8,9]]
f2=copy.deepcopy(f1)
for i in range(len(f1)):
for j in range(len(f2)):
f2[i][j]=f1[j][i]
print(f1)
print(f2)

3、#打印矩阵
f3=[[1,2,3],[4,5,6]]
f4=([[1,1],[1,1],[1,1]])
for i in range(len(f4)):
for j in range(len(f4)-1):
if i<=1:
f4[i][j-1]=f3[j-1][i]
elif i==2:
f4[i][j]=f3[j][i]
print(f3)
print(f4)

4、#判断数字
import random
nums=[]
repetition=[]
withoutrepetition=[]
for i in range(10):
nums.append(random.randrange(1,21))
print(nums)
length=len(nums)
for x in range(length):
print(‘number:{0}:出现次数:{1}’.format(nums[x],(nums.count(nums[x]))))
if nums.count(nums[x])>=2:
repetition.append(‘{}:’.format(nums[x]))
elif nums.count(nums[x])==1:
withoutrepetition.append(‘{}: ‘.format(nums[x]))
print(“重复的数字是”,set(repetition))
print(“不重复的数字是”,withoutrepetition)

5、#简单选择排序

b=[1,3,5,7,2,8,6,9,4]
length=len(b)
for i in range(length):
maxindex=i
for j in range(i+1,length):
if b[j]>b[maxindex]:
maxindex=j
if i!=maxindex:
b[i],b[maxindex]=b[maxindex],b[i]
print(a)

6、利用字典打印用户输入的数字

num=input(‘please input’)
d={}
for i in num:
if i not in d.keys():
d[i]=1
else:
d[i]+=1
print(d)

7、数字重复次数统计

import random
nums=[]
d={}
for i in range(100):
nums.append(random.randint(-1000,1000))
#print(nums)

for j in nums:
if j not in d:
d[j]=1
else:
d[j]+=1
#print(d)
d1=sorted(d.items())
print(d1)

8、字符串统计

a=’abcdefghijklmnopqrstuvwxyz’
d={}
words=[]
for i in range(100):
words.append(random.choice(a)+random.choice(a))
print(words)

for j in words:
if j not in d.keys():
d[j]=1
else:
d[j]+=1
print(d)
d1=sorted(d.items())
print(d1)

9、返回1-10平方的列表

lst = [(i**2) for i in range(1,11)]
print(lst)

10、有一个列表lst = [1,4,9,16,2,5,10,15],生成一个新列表,要求新列表元素是lst相邻2项的和

lst = [1,4,9,16,2,5,10,15]
lst1 = [lst[i]+lst[i+1] for i in range(len(lst)-1)]
print(lst1)

11、打印九九乘法表

[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)]

12、“0001.abadicddws” 是ID格式,要求ID格式是以点号分割,左边是4位从1开始的整数,右边是
10位随机小写英文字母。请依次生成前100个ID的列表。

import random
[‘{:04}.{}’.format(j,”.join(random.choice(bytes(range(97,123)).decode())for i in range(10))) for j in range(1,101)]

 

 

本文来自投稿,不代表Linux运维部落立场,如若转载,请注明出处:/95141

发表评论

登录后才能评论

联系我们

400-080-6560

在线咨询:点击这里给我发消息

邮件:1823388528@qq.com

工作时间:周一至周五,9:30-18:30,节假日同时也值班

友情链接:万达娱乐主管  万达开户  万达招商  万达主管QQ  万达娱乐招商  万达娱乐招商  万达注册  万达直属  万达注册  测试