Linux运维部落 |国内最专业的Linux万达登录,万达娱乐登录 Sat, 23 Sep 2017 12:09:34 +0000 zh-CN hourly 1 https://wordpress.org/?v=4.8.2 python第二周 /87533 /87533#respond Sat, 23 Sep 2017 11:24:02 +0000 /87533 #python数据结构(list)

## 分类

数值型:int、float、complex、bool

序列对象:字符串 str 列表 list 元组 tuple

键值对: 集合 set 字典 dict

 

## 数字的处理函数

math.e math.pi: 自如常数和π

round(): 四舍六入五去偶

floor(): 取整数位

ceil(): 整数位 +1

min(): 取最小的那个

max(): 取最大的那个

pow(): 等于x**y

math.sqrt(): 取根号

bin() oct() hex() : 二进制、八进制、十六进制

 

## 类型判断

type(object) , 返回类型,不是字符串

isinstance(object , class_or_tuple) 例如: isinstance(‘a’ , int) 返回的是False

 

## 列表list

定义:列表是一个队列,有若干个元素组成,可以是任意对象(数字、字符串、对象、列表),并且是可变的

lst = list() lst = [] lst = [1,2,3,’abc’] lst = list(range(5))

列表索引访问:

正索引:从左到右,从0开始,为列表中每一个元素编号

负索引:从右到左,从-1开始

list[index],列表通过索引可以访问,使用中括号。

列表查询:

index(value,[start,[stop]]):从指定区间查找匹配的元素,匹配到第一个就立即返回索引。

count(value) 返回列表中匹配的次数

时间复杂度:O(1) 、O(n) 、O(n^2)、O(n^3),n越大耗时越长,效率越低。

len():返回列表元素的个数

列表元素的修改:

list[index] = value

列表增加、插入元素

list1.append(object) 时间复杂度O(1)

list1.insert(index,object) 时间复杂度O(1)

list1.extend(list2) 将可迭代对象元素追加进来,就地修改

list1 + list2 连接操作,将两个列表连接起来,产生新的列表,原列表不变

list1*5 本列表中的元素将重5次,返回新的列表

列表删除元素

remove(value):从左至右查找第一个匹配value的值,并移除该元素,返回None,就地修改

list1.pop([index]):不指定索引就从尾部弹出一个元素,指定索引就从索引处弹出元素

list1.clear():清除列表中的所有元素,剩下一个空列表

列表其他操作

list1.reverse():将列表反转,就地修改

list1.sort(key=None,reverse=False):对列表进行排序,就地修改,默认升序;reverse为True,反转,降序。key一个函数,指定key排序。

列表复制

list2 = list1.copy() 返回一个新列表

shadow copy:浅拷贝,遇到引用类型,只复制一个引用而已

lst5 = copy.deepcopy(lst0) :深拷贝。重新创建一个新的列表,让lst5指向它

随机数

random模块

randint(a,b):返回[a,b]之间的整数

choice(seq) : 从非空序列的元素中挑选一个 random.choice(range(10)),从0到9中随机挑选一个整数[1,3,5,7]

randrange([start,] stop [,step]) 按指定基数递增的集合中获取一个随机数。例如:random.randage(1,7,2)

random.shuffle(list):就地打乱列表元素。

 

## 数列解决100以内素数问题

importmath
prime=[]
flag=False
foriinrange(2,100):
forjinprime:
ifi%j==0:
flag=True
break
ifj>=math.ceil(math.sqrt(i)):
flag=False
break
ifnotflag:
prime.append(i)
print(prime)

 

## 杨辉三角

法1:

triangle=[]
n=6
foriinrange(n):
ifi==0:
triangle.append([1])
else:
pre=triangle[i-1]
cur=[1]
forjinrange(0,i-1):
cur.append(pre[j]+pre[j+1])
cur.append(1)
triangle.append(cur)
print(triangle)
法1(2):

tri=[]
n=6
foriinrange(n):
row=[1]
tri.append(row)
ifi==0:
continue
forjinrange(i-1):
row.append(tri[i-1][j]+tri[i-1][j+1])
row.append(1)
print(tri)

法2:

n = 6
oldline = []
newline = [1]
length = 0
print(newline)
for i in range(1, n):
oldline = newline.copy()
oldline.append(0)
newline.clear()
for j in range(i+1):
newline.append(oldline[j-1] + oldline[j])
print(newline)

法3 :

triangle = []
n = 6
for i in range(n):
row = [1]*(i+1)
triangle.append(row)
if i == 0:
continue
for j in range(1,i//2+1):
val = triangle[i – 1][j-1] + triangle[i – 1][j]
row[j] = val
if j != i – j: #判断要不要对称复制
row[-j-1] = val
print(triangle)

 

# python数据结构(tuple)

## 元组定义

元组是一个有序的元素组成的集合,()表示,元组是不可变对象。

t = (22,) t = (2,)*7 t = (1,2,3)*6

元组查询和元素索引访问与列表相似

 

## 命名元组namedtuple

from collections import namedtuple

Point = namedtuple(‘Point’,[‘x’,’y’])

p = Point(11,22)

>>> p.x = 11 p.y = 22

Student = namedtuple(‘Student’,’name age’)

tony = Student(‘tony’,17)

petter = Student(‘petter’,18)

>>>petter.name = petter

 

## 冒泡法

时间复杂度O(n^2)

num = [1,9,3,5,7,6,8,2,4]
for i in range(len(num)):
flag = False
for j in range(len(num)-i-1):
if num[j] > num[j+1]:
tmp = num[j]
num[j] = num[j+1]
num[j+1] = tmp
flag = True
if not flag: #为了判断是否在前一步就已经完成
break
print(num)

 

# 字符串

## 字符串定义
字符串由一个个字符组成的序列,使用单双三引号引住,具有不可变属性

s1 = ‘string’ s2 = r’hello \n magedu.com’

 

## 字符串连接

“string”.join(iterable)

例如:lst = [‘1′,’2′,’3’]

 

 

## 字符串分割

split:将字符串按照分隔符分割成若干字符串,并返回列表

partition:将字符串按照分隔符分割成2段,返回这2段和分隔符的元组

 

## 字符串判断

s.startswith(‘very’,5) >>>True

s.endswith(‘very’,5) >>> False

s.endswith(‘sorry’,5,-1) >>>False

 

## 字符串判断

isalnum() 判断是否是字母数字组成

isalpha() 判断是否是字母

isdecimal() 是否只包含十进制

isdigit() 是否全部数字

isidentifier() 判断是不是标识符

islower() 是否小写

isupper() 是否大写

isspace() 是否空格字符

 

## 字符格式化

“{}{}”.format(*args,**kwargs) #arg是一个元组

“{}:{}”.format(‘192.168.1.100’,8888)

“{server} {1}:{0}”.format(8888, ‘192.168.1.100’, server=’Web Server Info : ‘)

访问元素:

“{0[0]}.{0[1]}”.format((‘magedu’,’com’))

对象属性访问:

from collections import namedtuple

Point = namedtuple(‘Point’,’x y’)

p = Point(4,5)

“{{{0.x},{0.y}}}”.format(p)

对齐:

‘{0}*{1}={2:<2}’.format(3,2,2*3)

‘{0}*{1}={2:<02}’.format(3,2,2*3)

‘{0}*{1}={2:>02}’.format(3,2,2*3)

进制:

octets = [192, 168, 0, 1]

‘{:02X}{:02X}{:02X}{:02X}’.format(*octets)

 

## 练习

输入一串数字,判断是几位数字,打印每一位数字及其重复的次数,一次打印个十百千万位
num = “”
print(‘请输入一个数字’)
while True:
num = input().strip().lstrip(‘0’)
if num.isdigit():
break
else:
print(‘不合规范重新输入’)
print(‘{}’.format(len(num)))

count = [0]*10

for i in range(10):
count[i] = num.count(str(i))
for i in range(10):
if count[i]:
print(‘数字{}出现的次数是{}’.format(i,count[i]))
lst = list(num)
lst.reverse()
print(lst)

 

## 倒序打印

(1)

for i in range(len(num),0,-1):

print(i,end = ‘ ‘)

print()

(2)

for i in reversed(num):

print(i,end=’ ‘)

print()

(3) 负索引打印

for i in range(len(num)):

print(num[-i-1],end=” “)

print()

 

## 判断0-9的字数在字符串中出现的次数。

(1) 迭代字符串中本身的字符

counter = [0]*10

for x in num:

i = int(x)

if counter[i] == 0:

counter[i] = num.count(x)

print(“The count of {} is {}”.format(x,counter[i]))

(2) 迭代字符串本身的字符

counter = [0]*10

for x in num:

i = int(x)

counter[i] += 1

for i in range(len(counter)):

if counter[i]:

print(“The count of {} is {}”.format(i,counter[i]))

 

## bytes 、bytearry

bytes:不可变字节序列

bytearray:字节数组,可变

编码:字符串按照不同的字符集编码encode返回字节序列bytes

encode(encoding = ‘utf – 8’,error = ‘strict’)

解码:字节序列按照不同的字符集解码decode返回字符串

bytes.decode(encoding=’utf – 8′,error = ”strict)

bytearray.decode(encoding=’utf – 8′,error = ”strict)

bytes(string,encoding) 等价于 string.encode()

用法: 和str类似

b’abcdef’.replace(b’f’,b’k’)

b’abc’.find(b’b’)

bytes.fromhex(string) —->>返回字符串

‘abc’.encode().hex() —->> 返回一个十六进制数

索引:b’abcdef'[2],返回该字节对应的数。int类型

 

bytearray操作:

与bytes类型的方法相同

bytearray(b’abcdef’).replace(b’f’,b’g’)

bytearray(b’abcdef’).find(b’f’) ——->> 返回5

hex():

bytearray.fromhex(‘6162 09 6a 6b00’)

bytearray(‘abc’.encode()).hex()

索引:

bytearray(b’abcdef’)[2] —–>>返回int类型对应的数

内置操作:

append(),insert(),extend(),pop(),remove() 用法与list相似 PS:(使用时int类型)

clear() 清空, reverse() 反转,就地修改

 

## 切片操作( 方向向右为正,否则步长为负 )

线性结构:可迭代for…in…

len()方法获取长度

通过下标可以访问

‘www.magedu.com’[4:10] >>>magedu

‘www.magedu.com’[4:10] >>>www.magedu

b’www.magedu.com'[-40:10] >>>b’www.magedu’

bytearray(b’www.magedu.com’)[-4:-10:-2] >>>bytearray(b’.dg’)

 

 

]]>
/87533/feed 0
删除boot,同时删除/etc/fstab,如何恢复 /87515 /87515#respond Sat, 23 Sep 2017 10:24:44 +0000 /87515 删除boot,同时删除/etc/fstab,如何恢复

/etc/fstab文件丢失的时候,得光盘启动进入linux rescue下。

挂载好cdrom后,按ctrl+alt+del,然后按f2,进入bios,调整为cdrom启动,然后reboot,进入linuxrescue急救模式
/etc/fstab配置文件决定了linux系统在启动后如何加载各个分区,如果分区无法加载,系统也将没有办法启动,启动时会报错。
可以光盘启动进入linux rescue,通过手动方式查找并挂载分区。(光盘启动时候的shell环境下内容为光盘内容,不是硬盘内容,所以要找到硬盘分区中的内容并挂载到一个挂载点(例如:/aa),在此挂载点/aa上重新建立fstab文件,这时候重新建立的fstab文件是挂载在/aa的硬盘分区上的,修改好后,就可以重新启动系统 了)。
在急救模式的shell环境中要扫描分区或逻辑卷,以便找到/分区设备,手动挂载根分区,并重建fstab配置文件。

1:如果有逻辑卷,如下:

#lvm vgscan
#lvm vgchange -ay –激活逻辑卷(有多少个逻辑卷,就激活多少个)
激活以后,
mkdir /aa
#mount /dev/vg_xyy/lv_root /aa(此时的/aa就相当于实际硬盘的/)
#vi /aa/etc/fstab –建立fstab文件。(编辑好fstab文件后,重启系统,over)

下面讨论有逻辑卷的情况:

显示*的则为根分区

搜狗截图17年09月23日1741_1

搜狗截图17年09月23日1743_2

搜狗截图17年09月23日1743_3

搜狗截图17年09月23日1745_5

搜狗截图17年09月23日1745_6

营救模式下的vi不方便使用,所以在营救模式开启的时候,记得开启网络以方便远程连接,编辑好fstab文件后用scp命令发送到破坏了/etc/fstab文件的机器上。

 

]]>
/87515/feed 0
排序 冒泡法 /87489 /87489#respond Sat, 23 Sep 2017 08:16:30 +0000 /87489 冒泡法属于交换排序,两两比较大小,交换位置 n=[1,20,3,47,81,5,4,6,57,7,8,9] m=len(n) count=0 count_swap=0 for i in range(m): flag=False for j in range(m-i-1): count+=1 if n[j]>n[j+1] : tmp=n[j] n[j]=n[j+1] n[j+1]=tmp flag=True count_swap+=1 if not flag : break print(n,count,count_swap) ]]> /87489/feed 0 Python 数据结构 /87488 /87488#respond Sat, 23 Sep 2017 07:58:31 +0000 /87488 python 内置数据结构python 内置数据结构
数字的处理函数:

round() 五舍六入 2.5 2 2.6 3

floor() 向下取整 2.5 2 2.6 2

ceil() 向上取整 2.5 3 2.6 3

min() 取最小的 1,2,3 1

max() 取最大的 1,2,3 3

pow(2,3) 2的n次方 2**3 = 8

type(obj) 返回类型,而不是字符串

list

一个队列,一个排列整齐的队伍 列表内的个体称作元素,由若干元素组成列表 元素可以是任意对象(数字,字符串,对象,列表) 列表内元素有序,可以使用索引 线性的数据结构 使用[]表示 列表是可变的
列表的定义及初始化 list() lis=[1,2] lis=[]
列表索引访问 list[index]
列表的查询 index(value,[start,[stop]])
列表元素修改 list[index]=value
列表增加,插入元素

lis.append(object) 尾部增加

lis.insert(index.object)

在指定索引index处插入元素 + 连接操作,将两个劫镖连接起来 * 重复操作,将列表元素重复n次。返回新的列表
列表元素删除

lis.remove(value) lis.pop() 不指定从列表尾部弹出一个元素,指定就从索引处弹出以恶搞元素 lis.clear() 清楚列表所有元素,剩下一个空列表
列表其他操作

lis.reverse() 将列表元素反转,就地修改

lis.sort(key=None,reverse=False) 排序默认不反转
列表复制 浅copy(只是复制引用而已) 和 深copy
随机数:为随机 random 模块

random.randint(1,10) 随机1-10之间的整数

random.choice([1,2,3,4])或者(range(9)) ()括号是非空序列集合,然后随机挑选一个 random.randrange(1,10,2) 从一到10每次加2随机

randmon.shuffle(list) 就地打乱列表元

元组

元组是一个有序的元素组成的集合,使用()表示,元组是不可变对象 元组是只读的,所以增,改,删方法都没有

t=() 定义一个空元组

t=(1,) 一个元素元组的定义元组

元素的访问 支持正负索引

正索引:从左至右,从零开始,为列表中每一个元素编号

负索引:从右至左,从-1开始

t=(9,8,6,5,3,4) t[2]=6 t[-4]=6

元素查询

t=(9,8,6,5,3,4,3) 根据value查询 开始索引 到 停止索引

t.index(3) t.index(3, 1, 7)

返回列表中匹配value的次数 count(value) t.count(3)

返回元素的个数

len(tuple)

len(t)

命名元组 namedtuple 意思是一个命名的元组,返回一个元组的子类,并定义字段 namedtuple(typename,field_names,verbose=False,rename=False) 类型名称 字段 详情名打印 允许修改名字

字符串

一个个字符组成的有序的序列,是字符的集合 使用单引号,双引号,三引号引住的字符序列 字符串是不可变对象

‘dddd’ “sssss” ”’dasdsadas”’ python3起,字符串就是Unicode类型
字符串的定义 初始化

str1 = ‘wwww.cofk’
字符串元素访问 — 下标 字符串支持使用索引访问

sq = “select * from user where name=’tom'” sq[4] = c
字符串join连接

string.join(iterable)

a = ‘asdf’ ‘,’.join(a) ->> ‘a,s,d,f’

字符串 + 连接

a = ‘asdf’ b = ‘fdsa’ a + b –>> ‘asdffdsa’
字符串分割

split(sep=None,maxsplit=1) 从左到右 sep 指定分割字符串,缺省的情况下空白字符串作为分隔符 maxsplit 指定分割的次数,-1 表示遍历整个字符串

rsplit(sep=None,maxsplit=-1) 从右到左 sep 指定分割字符串,缺省的情况下空白字符串作为分隔符 maxsplit 指定分割的次数,-1 表示遍历整个字符串

splitlines([keepends])

按照行来切分字符串 keepends 指的是是否 保留行分隔符 行分隔符包括 \n \r\n \r字符串分割* partition(sep) > 返回的是一个元组 从左至右,遇到分隔符就把字符串分割成两部分,返回头,分隔符,尾三部分的三元组,如果没有找到分隔符,就返回2个空元素的三元组 sep 分割字符串 必须指定
rpartition(sep) –>> (head,sep,tail)
字符串大小写

upper() 全大写

lower() 全小写

swapcase() 交互大小写
字符串排版

title() 标题的每个单词都大写

capitalize 首个字母大写

center(width[,fillchar])

zfil(width)

ljust(width[,fillchar])

rjust(width[,fillchar])

字符串修改

replace(old,new[,count])

‘www.magedu.com’.

replace(‘w’,’p’) 把所有的W都替换成p

‘www.magedu.com’.replace(‘w’,’p’,2) 把第1个和第2个W换成p

‘www.magedu.com’.replace(‘w’,’p’,3) 把 第1,2,3个W换成p

‘www.magedu.com’.replace(‘ww’,’p’) 把两个w换成一个p

‘www.magedu.com’.replace(‘www’,’python’,2) 把3个w替换成python
strip([chars]) 从字符串两端除去指定的字符集chars中的所有字符 如果没有指定,去除两端的空白字符 lstrip([chars]) 从左边开始

rstrip([chars]) 从右边开始

字符串查找

find(sub[,start[,end]]) 在指定区间[start,end],从左到右,查找子串sub,找到返回索引,没有找到返回-1
rfind(sub[,start[,end]]) 在指定区间,从右到左查找
str.find(” “,5) 从5开始

str.find(” “,5,11) 从5开始到11结束
str.index(sub[,start[,end]])
count(sub[,start[,end]]) 从左到右,统计子串sub出现的次数 str.count(‘s’) str.count(‘s’,5)
endswith(suffix[,start[,end]]) 字符串是否以suffix结尾 startwith(prefix[,start[,end]]) 字符串是否以prefix开始
字符串判断

isanum() 判断是否是字母和数字组成

isalpha() 判断是否是字母

isdecimal() 是否只包含十进制数字

isdigit() 是否全部是数字

isidentifier() 是不是字母和下划线开始

islower() 判断是否小写

isupper() 判断是否大写

isspace() 是否只包含空白字符

字符串格式化 字符串的格式化是一种拼接字符串输出样式的手段,更灵活方便

‘l am %03d’%(20) –>> ‘l am 020’

‘l like %s.’%’Python’
format 函数式字符串语法 — python 鼓励使用

“{} {}”.format(*args,**kwargs) — str

{} 花括号表示占位符 位置参宿

“{}:{}”.format(‘192.16.1.1′,8888) 关键字或命名参数 “{server} {1}:{0}”.format(8888,’192.168.1.1’,server=”Web Server info:”)

访问元素

“{0[0]}.{0[1]}”.format((‘magedu’.’com’))
“{0}*{1}={2:<2}”.format(3,2,6) “{0}*{1}={2:02}”.format(3,2,2*3)

bytes、bytearr

bytes和bytearray 是Python3引入两个新的类型 bytes 是不可变字节序列 bytearray 字节数组 可变
字符串与bytes

字符串是字符组成的有序序列,字符可以使用编码来理解 字符串按照不同的字符集编码encode返回字节序列bytes
字节序列按照不同的字符的字符集解码decode返回字符串

bytes定义

bytes() 空bytes

bytes(int) 指定字节的bytes,被0填充

bytes(iterable_of_ints)–>>bytes[0,255]的int组成的可迭代对象

bytes(string,encoding[,errors])–>> bytes 等价于string.encode() bytes(bytes_or_buffer)–>>immutable copy of bytes_or_buffer 从一个字节序列或者buffer复制一个新的不可变的bytes对象
使用b前缀定义 bytes 操作 和str类型类似,都是不可变类型,所以方法很多一样,只不过bytes的方法输入是bytes,输出是bytes
替换操作:

b”abcda”.replace(b’f’,b’k’)

查找操作:b”adsd”.find(b’b’)
hex() 返回16进制表示的字符串

bytearray bytearray() 空bytearray

bytearray(int) 指定字节的bytearray,被0填充

bytearray(iterable_of_ints)–>>bytearray[0,255]

bytearray(string,encoding[,errors]) bytearray

近似string.encode() 不过返回可变对象 bytearray(bytes_of_buffer) 从一个字节序或buffer复制出一个新的可变的bytearray对象
bytearray 操作

bytearray(b’abcdef’).replace(b’f’,b’k’)

bytearray(b’abc’).find(b’b’) hex() 返回16进制的字符串

bytearray(‘abc’.encode()).hex() 索引

bytearray(b’adfds’)[2] 返回该自己对应的数,int类型

append(int) 尾部追加一个元素 inster(index,int) 在指定索引位置插入元素

extend(iterable_of_ints) 将一个可迭代的整数集合追加到当前bytearray
pop(index=-1) 从指定索引上移除元素,默认从尾部移除

remove(value) 找到第一个value移除,找不到抛ValueError 异常

clear() 清空bytearray reverse()

翻转bytearray,就地修改

线性结构

可迭代 for…in.. len() 可以获取长度 通过下标就可以访问

可以切片 列表 元组 字符串 bytes bytearray
切片 通过索引区间访问线性结构的一段数据 sequence[start:stop] 表示返回[start,stop)区间的子序列 支持负索引 start为0,可以省略 stop为末尾,可以省略 start一定要在stop的左边 [:] 表示从头至尾,全部元素被取出,等效于copy()方法
步长切片 [start:stop:setp] step 为步长,可以正,可以负,默认是1 step要和start:stop同向,否则返回空序列

 

]]>
/87488/feed 0
数据结构-线性结构list,tuple,str,bytes,bytearray /87486 /87486#respond Sat, 23 Sep 2017 07:40:58 +0000 /87486 数据结构-线性结构
list,tuple,str,bytes,bytearray

list,tuple,str,bytes,bytearray都是有序的,可以被索引,使用[]。list与bytearray是可变的,tuple,str,byter是不可变的。
一:通用的方法
1:index(value),匹配value,匹配到返回索引值,匹配不到抛出异常ValueError.
2:count(value),匹配到value的次数
3:len(),元素的总个数
4:可以+,*
5:切片 [start:stop],返回[start,stop)区间的序列。[:]表示复制
二:list与bytearray通用的方法
1:append(object),尾部追加
2:insert(index,object),插入
3:extend(iterable),将可迭代对象的元素追加进来
4:pop(index),删除指定的元素,不指定,末尾删除
5:clear(),清空
6:reverse(),反转
三:list 排序
1:sort(key=none,reverse=False),升序,如果reverse=True,降序,()默认升序
四:tuple
1:namedtuple:
from collections import namedtuple
Point=namedtuple(‘Point’,[‘x’,‘y’]
P=Point(1,2)
P输出Point(x=1,y=2)
五:str,bytes,bytearray
1:split,partition可以切str,bytes,bytearray。split不保留切割点,partition保留切割点
2:strip(),从两端去除,如果()里没有,去除空白字符,lstrip从左,rstrip从右
3:find(value),查找value
4:endswith(),startswith(),判断是否以某开头,结尾,返回bool
六:str格式化***
1:模式 ‘{}’.format()
七:bytes,bytearray
1:encode返回的类型为bytes。decode返回的类型为str

 

 

]]>
/87486/feed 0
元组冒泡法及字符串处理 /87485 /87485#respond Sat, 23 Sep 2017 07:20:30 +0000 /87485 ##元组冒泡法及字符串处理
元组tuple:
  • 不可变对象,有序的序列。
  • 使用()表示
  • 空元组基本没用,因为不可变
  • 当元组只有一个元素时请用(1,)
In [15]: t=(1,)*5
In [16]: t
Out[16]: (1, 1, 1, 1, 1)
In [18]: id(t)
Out[18]: 275970285904
In [20]: t=t*5
In [21]: t
Out[21]: (1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1)
In [22]: id(t)
Out[22]: 275969422624#通过两个id的比较证明元组只能重新定义不可修改
In [23]: t=(range(1,7,2))#此处需要注意,()不能正常显示range函数
In [24]: t
Out[24]: range(1, 7, 2)
In [25]: type(t)
Out[25]: range
In [26]: t=tuple(range(1,7,2))#这样可以正常显示想要显示的range函数
In [27]: t
Out[27]: (1, 3, 5)
元组的访问
  • 支持索引(下标)
  • 支持正负索引,索引不可以越界,否则引发异常indexerror
  • tuple[index],index就是索引,使用中括号访问。
元组查询
  • index(value,[start,[stop]])
    • 通过值value,从指定区间查找列表内的元素是否匹配
    • 匹配到第一个就立即返回索引
    • 匹配不到,抛出异常valueerror
In [31]: t
Out[31]: (1, 3, 5)
In [32]: t.index(3)
Out[32]: 1
In [33]: t.index(3,0,5)#注意end可以指定比最后一个索引大的数值。
Out[33]: 1
In [37]: t.index(4,0,5)
—————————————————————————
ValueError Traceback (most recent call last)
<ipython-input-37-d3ce7b01939a> in <module>()
—-> 1 t.index(4,0,5)
ValueError: tuple.index(x): x not in tuple##此处不是报valueerror,而是提示vlue not in tuple

  • count(value):返回列表中匹配value的次数
In [41]: t
Out[41]: (1, 3, 5)
In [42]: t.count(3)
Out[42]: 1
In [43]: t.count(4)
Out[43]: 0#匹配不到显示零,不会报错
  • 时间复杂度:index和count都是O(n),随着元组元素的规模的增大,而效率下降。
  • len(tuple):返回元素的个数
  • 元组是只读的,所以增删改方法都没有。可以理解成权限更低的列表。
  • 元组节约内存,比列表
  • 目的:不让其他人改变元素,可当做只读列表
  • 引用类型可以变,相当于换了一件衣服:例如:t=(1,[2,3],4):此处23可以修改

命名元组namedtuple
  • 目的:如果tuple中的元素很多的时候操作起来就比较麻烦,有可能会由于索引错误导致出错。namedtuple对象就如它的名字说定义的那样,你可以给tuple命名。
  • namedtuple方法在collections方法集中,所以使用需要from collections import namedtuple
  • namedtuple(typename,field_names,verbose=False,rename=False)
    • 命名元组,返回一个元组的子类,并定义了字段
    • field_names可以是空格或逗号分割的字段的字符串,可以是字段的列表
In [50]: from collections import namedtuple
In [51]: Point=namedtuple(‘_Point’,[‘x’,’y’])
In [52]: p=Point(4,5)
In [53]: p.x+p.y
Out[53]: 9
In [55]: P=namedtuple(‘a’,[‘x’,’z’])#此处的a是field_names,必须是字符形式的非数字
In [56]: p
Out[56]: _Point(x=4, y=5)
In [57]: P
Out[57]: __main__.a
In [58]: c=P(4,5)
In [59]: cx
In [70]: d=namedtuple(1,[‘x’,’y’])#此处证明field_names不可以是数字,加上引号也不可以
—————————————————————————
NameError Traceback (most recent call last)
<ipython-input-59-c2e08fa19a2c> in <module>()
—-> 1 cx
NameError: name ‘cx’ is not defined#调用方法出错
In [60]: c.x
Out[60]: 4
In [67]: d=namedtuple(‘0’,[‘x’,’y’])
—————————————————————————
ValueError Traceback (most recent call last)
<ipython-input-67-5f18d65cc1d7> in <module>()
—-> 1 d=namedtuple(‘0’,[‘x’,’y’])
c:\users\devops\appdata\local\programs\python\python35\lib\collections\__init__.py in namedtuple(typename, field_names, verbose, rename)
401 if not name.isidentifier():
402 raise ValueError(‘Type names and field names must be valid ‘
–> 403 ‘identifiers: %r’ % name)
404 if _iskeyword(name):
405 raise ValueError(‘Type names and field names cannot be a ‘
ValueError: Type names and field names must be valid identifiers: ‘0’
[使用举例]
In [72]: Student=namedtuple(‘Student’,’name age’)
In [74]: tom=Student(‘Thunk’,29)#实例化对象
In [75]: tom.name#用名称调用value
Out[75]: ‘Thunk’
In [76]: tom.age
Out[76]: 29

练习:
  • 依次接受用户输入的3个数,排序后打印:
    • 转换int后,判断大小排序
    • 使用max函数
    • 使用列表的sort方法
    • 冒泡法

冒泡法
  • 属于交换排序
  • 两两比较大小,交换位置。如同水泡咕嘟咕嘟往上冒
  • 结果分为升序和降序排列
  • 升序:
    • n个数从左至右,编号从0开始到n-1,索引0和1的值比较,如果索引0大,则交换两者的位置,如果索引1大,则不交换。继续比较索引1和2的值,将大值放在右侧。直至n-2和n-1比较完,第一轮比较完成。第二轮从索引0比较到n-2,因为最右侧n-1的位置上已经是最大值了,依次类推,每轮都会减少最右侧的不参与比较,直至剩下最后两个数比较。
  • 时间复杂度为O(n)
num_list=[[1,9,8,5,6,7,4,3,2],[1,2,3,4,5,6,7,8,9],[1,2,3,4,5,6,9,8]]
nums=num_list[2]
print(nums)
length=len(nums)
count_swap=0
count=0
for i in range(length):
flag=False#每次循环初始化标签
for j in range(length-i-1):
count += 1
if nums[j] > nums[j+1]:
tmp=nums[j]
nums[j]=nums[j+1]
nums[j+1]=tmp
flag=True#此处如果修改下面的if语句永远不会执行
count_swap += 1
if not flag:
break
print(nums,count_swap,count)

字符串
  • 一个个字符组成有序的序列,是字符的集合
  • 使用单引号,双引号,三引号引住的字符序列
  • 字符串是不可变对象
  • Python3开始,字符串就是Unicode类型
  • 使用r/R将字符串中的特殊字符原样输出
    举例:
In [1]: s3=”’this’s a “string””’
In [3]: s3
Out[3]: ‘this\’s a “string”‘#####################`为什么自动加转义符??`
In [4]: s4=’hello \n magedu.com’
In [5]: s4
Out[5]: ‘hello \n magedu.com’
In [6]: s5=r’this \n Thunk lee’
In [7]: s5
Out[7]: ‘this \\n Thunk lee’
In [8]: print(s4)#此处证明在无r的情况下特殊字符具有特殊功效
hello
magedu.com
In [9]: print(s5)#在加有r的情况下,特殊字符串也是原样输出
this \n Thunk lee
In [10]: sql=”””select * from user where name=’tom'”””#三引号内可以使用单双引号
In [11]: print(sql)
select * from user where name=’tom’
字符串访问
  • 下标:字符串支持索引访问
  • 有序的字符集合,字符序列
  • 可迭代
字符串join连接
  • “指定分隔符”.join(iterable),用来连接字符串,其他类型不可以。
  • 可迭代对象内部必须是简单类型,复杂类型无法执行
    举例:
In [50]: “@”.join(“abcdefg”)##使用方法小括号内必须是可迭代对象,分隔符无所谓
Out[50]: ‘a@b@c@d@e@f@g’
In [51]: lst=[‘1’,[‘3′,’4′],’8’]##复杂类型无法处理
In [52]: “#”.join(lst)
—————————————————————————
TypeError Traceback (most recent call last)
<ipython-input-52-fa3d037801ad> in <module>()
—-> 1 “#”.join(lst)
TypeError: sequence item 1: expected str instance, list found
In [53]: lst=[‘1′,’4′,’8’]##简单类型正常处理
In [54]: “#”.join(lst)
Out[54]: ‘1#4#8’
In [56]: print(“\n”.join(lst))#使用换行符作为分隔符
1
4
8
In [57]: print(“\””.join(lst))#双引号作为分隔符
1″4″8
##疑问?lst=[1,2,3,4]是否可以用join,结果如下
In [1]: lst = [1,2,3,4]
In [2]: “#”.join(lst)
—————————————————————————
TypeError Traceback (most recent call last)
<ipython-input-2-fa3d037801ad> in <module>()
—-> 1 “#”.join(lst)
TypeError: sequence item 0: expected str instance, int found
In [3]: lst1=[“1″,”abc”,”345″]
In [4]: “#”.join(lst1)
Out[4]: ‘1#abc#345’
字符串连接
  • +:将两个字符串连接在一起,返回一先得字符串
In [58]: a=”abcdefg”
In [59]: b=”hijklmn”
In [60]: a+b
Out[60]: ‘abcdefghijklmn’
字符串分割
  • 1.split:将字符串按照分隔符分割成若干字符串,并返回列表
    • split(sep=None,maxsplit=-1)
      • 从左至右
      • sep指定分割字符串,缺省的情况下空白字符串作为分隔符
      • maxsplit指定分割次数,-1表示遍历整个字符串
    • rsplit:从右向左
    • splitlines([keepends])
      • 按照行来切分字符串
      • keepends指的是是否保留行分隔符
      • 行分隔符包括\n,\r\n,\r等
##split举例:
In [63]: s1=”I’m \ta super student”
In [64]: s1.split(sep=”,”)#由于没有此符号所以无法分割,注意必须拿元素中有的元素来分割
Out[64]: [“I’m \ta super student”]
In [65]: s1.split()#默认空格分隔‘ ’+
Out[65]: [“I’m”, ‘a’, ‘super’, ‘student’]
In [66]: s1.split(‘s’)#指定用s字符分割
Out[66]: [“I’m \ta “, ‘uper ‘, ‘tudent’]
In [67]: s1.split(“super”)#指定super来分割
Out[67]: [“I’m \ta “, ‘ student’]
##rsplit举例:
In [69]: s1.rsplit(“\t”,maxsplit=2)
Out[69]: [“I’m “, ‘a super student’]
In [70]: s1.rsplit(“s”,maxsplit=1)#此例子可以用于取路径中的文件名
Out[70]: [“I’m \ta super “, ‘tudent’]
In [71]: s=”/etc/sysconfig/network-scripts/ifcf-ens33″
In [72]: s
Out[72]: ‘/etc/sysconfig/network-scripts/ifcf-ens33’
In [73]: s.rsplit(“/”,1)
Out[73]: [‘/etc/sysconfig/network-scripts’, ‘ifcf-ens33’]
In [74]: list(s.rsplit(“/”,1))[1]
Out[74]: ‘ifcf-ens33’
  • 2.partition:将字符串按照分隔符分割成两段,返回这两段和分割符的tuple
  • partition(seq)
    • 从左至右,遇到分隔符就把字符串分割成两部分,返回头、分隔符、尾三部分的三元组;如果没有找到分隔符,就返回头、2个空元素的三元组
    • seq分割字符串,必须制定
  • rpartition(seq):从右至左,如果没找到分割符就返回两个空元素和尾的三元组
In [94]: s1.partition(“\n”)#此函数又叫一刀两段
Out[94]: (“i’m a super student.”, ‘\n’, “you’re a super teacher.”)
In [95]: s1.partition(“s”)
Out[95]: (“i’m a “, ‘s’, “uper student.\nyou’re a super teacher.”)
In [96]: s1.rpartition(“s”)#从右开始切
Out[96]: (“i’m a super student.\nyou’re a “, ‘s’, ‘uper teacher.’)
In [97]: s1.partition(“x”)#不存在的分隔符会用空元素补全
Out[97]: (“i’m a super student.\nyou’re a super teacher.”, ”, ”)
In [98]: s1.rpartition(“x”)
Out[98]: (”, ”, “i’m a super student.\nyou’re a super teacher.”)
In [99]: s1.rpartition(“”)#不指定分隔符则报错
—————————————————————————
ValueError Traceback (most recent call last)
<ipython-input-99-9151ec630fbe> in <module>()
—-> 1 s1.rpartition(“”)
ValueError: empty separator
字符串大小写
  • upper()全大写
  • lower()全小写
  • swapcase()互换大小写
In [106]: a.upper()#这些方法是字符串下的方法,所以需要用str.upper()来调用
Out[106]: ‘ABCDEF’
In [107]: a.lower()
Out[107]: ‘abcdef’
In [108]: a.swapcase
Out[108]: <function str.swapcase>
In [109]: a.swapcase()
Out[109]: ‘AbcDef’
字符串修改
  • replace(old,new[,count]):
    • 字符串中找到匹配替换为新字串,返回新字符串
    • count表示替换几次,不指定默认全部替换
In [113]: a=’asdlkfjiefjoefjjjjjj’
In [114]: a.replace(‘j’,’#’)
Out[114]: ‘asdlkf#ief#oef######’
In [115]: a.replace(‘j’,’#’,2)
Out[115]: ‘asdlkf#ief#oefjjjjjj’
  • strip([chars])
    • 从字符串两端去除制定的字符集chars中的所有字符默认两段开始,如果从某一端开始可能会影响结果
    • 如果没指定chars,默认去除端的空白字符
    • lstrip([chars]):从左开始
    • rstrip([chars]):从右开始
1.In [116]: s=’\r \n \t Hello Python \n \t’
2.In [117]: s
3.Out[117]: ‘\r \n \t Hello Python \n \t’
4.In [118]: s.strip()##默认去除空白字符
5.Out[118]: ‘Hello Python’
6.
7.In [119]: s1=”I am very very very sorry”
8.In [121]: s1.strip(“vy”)
9.Out[121]: ‘I am very very very sorr’
10.In [122]: s1
11.Out[122]: ‘I am very very very sorry’
12.In [123]: s1.strip(“v”)
13.Out[123]: ‘I am very very very sorry’
14.In [124]: s1.strip(“I”)
15.Out[124]: ‘ am very very very sorry’
16.In [125]: s1.strip(“Iry”)
17.Out[125]: ‘ am very very very so’#只要两端匹配到就删除
18.
19.#lstrip,rstrip举例:
20.In [127]: s=”I am very very very sorry “
21.In [128]: s.strip(“Iy “)#两端开始
22.Out[128]: ‘am very very very sorr’
23.In [129]: s.lstrip(‘Iy ‘)#左开始
24.Out[129]: ‘am very very very sorry ‘
25.In [130]: s.rstrip(‘Iy ‘)#右开始
26.Out[130]: ‘I am very very very sorr’
字符串查找
  • find(sub[,start[,end]]) –>int
    • 在指定区间内[start,end),从左到右查找子串sub。找到返回索引,没找到返回-1
    • rfind(sub[,start[,end]]):从右往左查
In [131]: a
Out[131]: ‘asdlkfjiefjoefjjjjjj’
In [134]: a.find(“j”,0,100)
Out[134]: 6
In [135]: a[6]
Out[135]: ‘j’
In [136]: a.rfind(“j”,0,100)#从右往左找到第一个sub返回index,区间可以为负索引
Out[136]: 19
In [137]: len(a)
Out[137]: 20
In [138]: a.rfind(“x”,0,100)#没找到元素返回-1
Out[138]: -1

  • index(sub[,start[,end]])—>int跟find区别:抛出异常与否.具体使用方法相同
    • 在指定区间内[start,end),从左到右,查找子串sub,找到返回索引,没找到抛出异常valueerror
    • rindex(sub[,start[,end]]),从右到左
In [138]: a.rfind(“x”,0,100)#返回-1
Out[138]: -1
In [139]: a.index(“x”,0,100)#抛出value异常
—————————————————————————
ValueError Traceback (most recent call last)
<ipython-input-139-88e7d48786fe> in <module>()
—-> 1 a.index(“x”,0,100)
ValueError: substring not found
字符串判断
  • endswith(suffix[,start[,end]])–>bool
    • 在指定区间[start,end),字符串是否是suffix结尾
  • startswith(prefix,[,start[,end]])–>bool
    • 在指定区间xxx,字符串是否已prefix结尾
In [183]: s
Out[183]: ‘I am very very very sorry’#string集合
In [184]: s.startswith(“very”)
Out[184]: False
In [185]: s.startswith(“very”,5)
Out[185]: True
In [186]: s.startswith(“very”,5,9)
Out[186]: True
In [187]: s.endswith(“very”,5,9)
Out[187]: True
In [188]: s.endswith(“sorry”,5)
Out[188]: True
In [189]: s.endswith(“sorry”,5,-1)#无法取到-1,因为是开区间
Out[189]: False
In [190]: s.endswith(“sorr”,5,-1)#去掉y可以证明-1导致的false
Out[190]: True
In [191]: s.endswith(“sorry”,5,100)
Out[191]: True
字符串判断is系列
  • isalnum()–>bool是否是字母和数字组成
  • isalpha():是否是字母
  • isdecimal()是否只包含十进制数字
  • isdigit()是否全部数字(0-9)
  • isidentifier()是不是字母和下划线开头,其他都是字母数字,下划线
  • islower()是否都是小写
  • isupper()是否都是大写
  • isspace()是否只包含空白字符
In [197]: s=”5″
In [198]: s.isdigit()
Out[198]: True#返回布尔值
In [199]: if s.isdigit():#字符串集合才可以使用
…: print(“Is number”)
Is number
字符串格式化
  • 字符串的格式化是一种拼接字符串输出样式的手段,更方便灵活
    • join拼接只能使用分隔符,且要求被拼接的是可迭代对象
    • +拼接字符串还算方便,但是非字符串需要先转换成字符串才能拼接
  • format函数格式字符串语法
    • “{} {xxx}”.format(*args,**kwargs)–>str
    • args是位置参数,是一个元组
    • kwargs是关键字参数,是一个字典
    • 花括号表示占位符
    • {}表示按照顺序匹配位置参数,{n}表示取位置参数索引为n的值
    • {xxxx}表示在关键字参数中搜索名称一致的
    • {{}}表示打印花括号
##用法举例:
#位置参数:
In [216]: “{}:{}”.format(‘192.168.0.1’,9999)
Out[216]: ‘192.168.0.1:9999’
#关键参数:
In [218]: “{server}:{}:{}”.format(“192.168.0.1″,8888,server=”app”)
Out[218]: ‘app:192.168.0.1:8888’
#访问元素:
In [223]: “{0[0]},{1[1]}”.format(“magedu”,”com”)
Out[223]: ‘m,o’
In [224]: “{0[0]},{1[2]}”.format(“magedu”,”com”)
Out[224]: ‘m,m’
In [225]: “{0},{1}”.format(“magedu”,”com”)
Out[225]: ‘magedu,com’
#对象属性访问
In [226]: from collections import namedtuple
In [227]: P=namedtuple(“P”,”x y”)
In [228]: p=P(4,5)
In [232]: “{}{}”.format(p.x,p.y)
Out[232]: ’45’
In [233]: “{0.x}{0.y}”.format(p)
Out[233]: ’45’
  • 对齐:
In [234]: ‘{0}*{1}={2:<2}’.format(2,3,2*3)#左对齐
Out[234]: ‘2*3=6 ‘
In [235]: ‘{0}*{1}={2:<02}’.format(2,3,2*3)
Out[235]: ‘2*3=60’
In [236]: ‘{0}*{1}={2:<02}’.format(2,3,2*3)
Out[236]: ‘2*3=60’
In [237]: ‘{0}*{1}={2:>02}’.format(2,3,2*3)
Out[237]: ‘2*3=06’
In [238]: ‘{:^30}’.format(“centered”)
Out[238]: ‘ centered ‘
In [239]: ‘{:*^30}’.format(“centered”)
Out[239]: ‘***********centered***********’
  • 进制:
In [240]: “int:{0:d}; hex:{0:x};oct:{0:n};bin:{0:b}”.format(43)
Out[240]: ‘int:43; hex:2b;oct:43;bin:101011’
In [241]: “int:{0:d}; hex:{0:#x};oct:{0:#n};bin:{0:#b}”.format(43)
Out[241]: ‘int:43; hex:0x2b;oct:43;bin:0b101011’
In [242]: octets=[192,168,0,1]
In [243]: ‘{:02X}{:02X}{:02X}{:02X}’.format(*octets)
Out[243]: ‘C0A80001’
]]>
/87485/feed 0
Python学习之Second_Week Notes /87484 /87484#respond Sat, 23 Sep 2017 07:11:26 +0000 /87484 # 数据结构分类:
数值型:
int、float、complex、bool

序列对象:
字符串:str
列表:list
tuple:

键值对:
集合:set
字典:dict

## 分类详解:

数值型:

1、int、float、complex、bool都是class

2、int:python3的int就是长整型,且没有大小限制,受限于内存区域的大小

3、float:有整数部分和小数部分组成。支持十进制和科学计数法表示。只有双精度型。

4、complex:有实数和虚数部分组成,实数和虚数部分都是浮点数,3+4.2j

5、bool:int的子类,仅有两个实例True、False对应1和0,可以和整数直接运算
类型转换(built-in):

int(x):返回一个整数
float(x):返回一个浮点数
complex(x)、complex(x,y):返回一个复数
bool(x):返回布尔值,False=0,True=1

## 数字的处理函数:
1、round():四舍五入,四舍六入五取偶
model:
round(4.6) 5
round(3.5) 4
round(4.5) 4

2、floor()地板、ceil()天花板
即一个向下取,一个向上取
model:
import math
math.ceil(2.5)
>>>3
math.floor(2.5)
>>>2

3、int():取整数部分,和//整除一样
model:
int(2.9)
>>>2

4、min():
取出最小的值
model:
min(1,8,2,0)
>>>0

5、max():
取出最大值
max(1,8,2,0)
>>>8

6、pow(x,y)等于x**y:
pow(x,y):返回的是x的y次方,如果是pow(x,y[,z]),其效果就等于x**Y % z
注意:pow() 通过内置的方法直接调用,内置方法会把参数作为整型,而 math 模块则会把参数转换为float
pow(2,4)
>>>16

pow(2,4,3)
>>>1

pow(2,4,4)
>>>0

7、math.sqrt():
sqrt():返回数字的平方根

math.sqrt(16)
>>>4.0

8、进制函数
1、bin():二进制

2、oct():八进制

3、hex():十六进制

9、math.pi :
数学常量 pi(圆周率,一般以π来表示)
math.pi
>>>3.141592653589793

10、math.e:
自如常数
math.e
>>>2.718281828459045

## 类型判断:
1、type(obj),返回类型,而不是字符串
type(1)
>>>int
type(1+True)
>>>int
type(1+True+2.0)
>>>float

2、isinstance(obj,class_or_tuple)
model:
isinstance(‘a’,str)
>>>True
isinstance(6,(str,bool,int))
>>>True

# 列表list

1、一个队列,一个排列整齐的队伍

2、列表内的个体称作元素,有若干个元素组成列表

3、元素可以是任意对象(数字、字符串、对象、列表等)

4、列表内元素有顺序,可以使用索引

5、线性的数据结构

6、使用[]表示

7、列表是可变的

8、列表list、链表、queue、stack(栈)的差异

a、链表:链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

b、queue:队列是一种特殊的线性表,是一种先进先出(FIFO)的数据结构。它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作。进行插入操作的端称为队尾,进行删除操作的端称为队头。队列中没有元素时,称为空队列。

c、stack:栈(stack)在计算机科学中是限定仅在表尾进行插入或删除操作的线性表。

列表list定义 初始化

list()->new empty list

list(iterable)->new list initialized from iterable’s iterms
列表不能一开始就定义大小

l1 = list()
l1 = []
l1 = [2,6,9,’ab’]
l1 = list(range(5))

列表索引访问:

1、索引也叫下标

2、正索引:从左至右,从0开始,为列表中每一个元素编号
l1
>>>[4, 7, 2, 1, 5, 9]
l1[0]
>>>4

l1[1]
>>>7

3、负索引:从右至左,从-1开始

l1[-1]
>>>9

l1[-2]
>>>5

4、正负索引不可以超界,否则引发异常IndexError
l1[6]
IndexError: list index out of range

5、为了理解方便,可以认为列表是从左至右排列的,左边是头部,右边是尾部,左边是下界,右边是上界

6、列表通过索引访问
a、list[index],index就是索引,使用中括号访问

# 列表查询
1、index(value,[start,[stop]])
a、通过值value,从指定区间查找列表内的元素是否匹配
l1
>>>[4, 7, 2, 1, 5, 9, 7, 7, 3, 7]

l1.index(7,2,7)
>>>6

b、匹配第一个就立即返回索引

c、匹配不到,抛出异常ValueError
l1.index(7,2,6)
>>>ValueError: 7 is not in list

2、count(value)
返回列表中匹配value的次数
l1.count(7)
>>>4

3、时间复杂度
a、index和count方法都是O(n)
b、随着列表数据规模的增大,而效率下降

4、len():返回元素的个数
len(l1)
>>>10

# 列表元素修改
索引访问修改:
1、list[index] = value
l1
>>>[4, 7, 2, 1, 5, 9, 7, 7, 3, 7]
l1[1]=0
>>>[4, 0, 2, 1, 5, 9, 7, 7, 3, 7]
2、索引不要超界

# 列表增加、插入元素
append(object)->None
1、列表尾部追加元素,返回None
l1.append(100)

l1
>>>[4, 0, 2, 1, 5, 9, 7, 7, 3, 7, 100]

lst.append(9)

lst
>>>[1, 2, 3, 2, 2, 5, 2, 9]

a = lst.append(10)
type(a)
NoneType
print(a)
返回None

2、返回None就意味着没有新的列表产生,就地修改
3、时间复杂度是O(1)

insert(index,object)->None
1、在指定的索引index处插入元素object
2、返回None就意味着没有新的列表产生,就地修改
3、时间复杂度是O(1)
4、索引能超上下界吗?
超越上界,尾部追加
超越下界,头部追加

extend(iteratable)->None
1、将可迭代对象的元素追加进来,返回None
2、就地修改

+->list
1、连接操作,将两个列表连接起来
l1
>>>[4, 0, 2, 1, 5, 9, 7, 7, 3, 7, 100]
l2
>>>[10, 11, 18, 14]
l3
>>>[4, 0, 2, 1, 5, 9, 7, 7, 3, 7, 100, 10, 11, 18, 14]
2、产生新的列表,原列表不变
l1
>>>[4, 0, 2, 1, 5, 9, 7, 7, 3, 7, 100]
l2
>>>[10, 11, 18, 14]
3、本质上调用的是__add__()方法

*->list
1、重复操作,将本列表元素重复n次,返回新的列表

l4 = 2*l2
l4
[10, 11, 18, 14, 10, 11, 18, 14]

# 列表删除元素
remove(value)->None
1、从左至右查找第一个匹配value的值,移除该元素,返回None
l4.remove(11)
l4
[10, 18, 14, 10, 11, 18, 14]

2、就地修改
3、效率?

pop([index])->item
1、不指定索引index,就从列表尾部弹出一个元素
l4.pop()
>>>14

l4
[10, 18, 14, 10, 11, 18]
2、指定索引index,就从索引处弹出一个元素,索引超界抛出IndexError错误
3、效率?指定索引的时间复杂度?不指定索引呢?

clear()->None
清除列表所有元素,剩下一个空列表
l3.clear()
l3
>>>[]

# 列表其它操作
reversed()->None
1、将列表元素反转,返回None
l1
>>>[4, 0, 2, 1, 5, 9, 7, 7, 3, 7, 100]
l1.reverse()
l1
>>>[100, 7, 3, 7, 7, 9, 5, 1, 2, 0, 4]

2、就地修改

sort(key=None,reverse=False)->None
1、对列表元素进行排序,就地修改,默认升序
l1.sort()
l1
>>>[0, 1, 2, 3, 4, 5, 7, 7, 7, 9, 100]

2、reverse为True,反转,降序
l1.sort(reverse=True)
l1
>>>[100, 9, 7, 7, 7, 5, 4, 3, 2, 1, 0]

3、key是一个函数,指定key如何排序
lst.sort=(key=functionname)

in:
[3,4]in [1,2,[3,4]]
for x in [1,2,3,4]
lst0 = list(range(4))
id(lst0)
hash(id(lst0))

lst1 = list(range(4))
id(lst1)

lst0 == lst1 取值比较,内容
True

lst0 is lst1 取id,就是内存地址比较
False

lst1 = lst2
lst2[2] =10

lst0 = [1,[2,3,4],5]
lst5 = lst0.copy()
lst0[1][1]= 20
那么lst0 == lst5为True,因为里面拷贝的为内存 地址

列表复制:
1、copy()->List
l1
>>>[100, 9, 7]
l2 = l1.copy()
l2
>>>[100, 9, 7]

l1 == l2
True

shadow copy返回一个新的列表
2、shadow copy
影子拷贝,也叫浅拷贝,遇到引用类型,只是复制了一个引用而已
3、深拷贝
copy模块提供了deepcopy

# 随机数
1、random模块
random.choice([1,2,3,4,5])
random.randint(0,1)
2、randint(a,b)返回[a,b]之间的整数
3、choice(seq)从非空序列的元素中随机挑选一个元素,比如random.choice(range(10)),从0到9中随机挑选一个整数。random.choice([1,3,5,7])
4、randrange([start,]stop[,step])从指定范围内,按指定基数递增的集合中获取一个随机数,基数缺省值为1.random.randrange(1,7,2)
5、random.shuffle(list)->None就地打乱列表元素

# 时间复杂度:
index和count方法都是O(n)
效率最高的是O(1)1表示为常数
最低的是O(n**2)

pass占位语句

 

tuple:
一个有序的序列,不可变
可以重复元素
所谓无序就是定义的顺序和打印的顺序不一样,但是可以遍历
可迭代对象构建:t=tuple(range(1,7,2))
t1= (1,)

转义:两个同符号或者\

0920练习:
元组tuple:
1、一个有序的元素组成的集合
2、使用小括号()表示
3、不可变对象

 

定义:
t = tuple()–空元组
t=()

“`
In [22]: t=tuple(range(1,9,2))

In [23]: t
Out[23]: (1, 3, 5, 7)
“`

In [24]: t = (2,4,6,1,7,9)

In [25]: t[1]
Out[25]: 4

单个元素的元组的定义:
t = (1,)
In [30]: type(t)
Out[30]: tuple

下面的做法是错误的:
In [27]: t = (1)

In [28]: type(t)
Out[28]: int

乘法的使用:
In [31]: t1 = t*5

In [32]: t1
Out[32]: (1, 1, 1, 1, 1)

访问:支持索引
In [35]: t1 = (1,2,6,8,0)

In [36]: t1[1]
Out[36]: 2

In [37]: t[-1]
Out[37]: 1

一旦定义,不可以修改,否则,就生成新的列表

tuple.index(value,[start,[stop]])

生成新的元组,可以使用:
In [44]: t = tuple(range(1,9,3))

In [45]: t
Out[45]: (1, 4, 7)
注:一定要使用tuple(range(x)),否则无法创建成功

In [47]: t.index(4,1,3)
Out[47]: 1
如果使用t.index(4,2,3),就会报议程错误,因为匹配不到

匹配次数:
In [48]: t.count(4)
Out[48]: 1

元组中元素的个数:
In [49]: len(t)
Out[49]: 3

# 因为元组是不可变的,所以不支持增删改

命名元组:
form collections import namedtuple

In [50]: from collections import namedtuple

In [51]: Point = namedtuple(‘_Point’,[‘x’,’y’])

In [52]: p = Point(89,24)

In [53]: p.x
Out[53]: 89

In [54]: p.y
Out[54]: 24

In [55]: Student = namedtuple(‘Student’,’name age’)

In [56]: tom = Student(‘tom’,20)

In [57]: jerry = Student(‘jerry’,18)

In [58]: tom.name
Out[58]: ‘tom’

In [59]: tom.age
Out[59]: 20

冒泡排序:
num_list = [1,2,3,4,5,6,7,9,8]
length = len(num_list)
count_swap = 0
count = 0

for i in range(length):
flag = False
for j in range(length-i-1):
count += 1
if num_list[j] > num_list[j+1]:
tmp = num_list[j]
num_list[j] = num_list[j+1]
num_list[j+1] = tmp
flag = True
count_swap += 1
if not flag:
break
print(num_list,count_swap,count)

 

字符串:
1、一个个字符组成的有序的序列,是字符的集合
2、使用单引号、双引号、三引号引住的字符序列
3、字符串是不可变对象

In [60]: s1 = ‘abc’

In [61]: s2 = “telephone”

In [62]: s3 = ”’My telephone number is “13938495980””’

In [67]: s1
Out[67]: ‘abc’

In [68]: s2
Out[68]: ‘telephone’

In [69]: s3
Out[69]: ‘My telephone number is “13938495980”‘

 

 

In [63]: s4 = ‘My name \n is Eric’

In [64]: s4
Out[64]: ‘My name \n is Eric’

 

In [70]: s5 = r”My name \n is Eric”

In [71]: s5
Out[71]: ‘My name \\n is Eric’

In [72]: s6 = ‘c:\windows\nt’

In [73]: s6
Out[73]: ‘c:\\windows\nt’

 

In [74]: s6 = R”c:\windows\nt”

In [75]: s6
Out[75]: ‘c:\\windows\\nt’

 

In [76]: s8 = ‘c:\windows\\nt’

In [77]: s8
Out[77]: ‘c:\\windows\\nt’

 

In [78]: sql = “””select * from user where name=’root'”””

In [79]: sql
Out[79]: “select * from user where name=’root'”
In [80]: sql[4]
Out[80]: ‘c’

 

In [82]: for c in sql:
…: print(c)
…: print(type(c))
…:
s
<class ‘str’>
e
<class ‘str’>
……

 

可以迭代:
lst = list(sql)

星号标记课件:
“string”.join(iterable)->str
1、使可迭代的对象连接起来,使用string作为分隔符
2、可迭代对象本身元素都是字符串
3、返回一个新字符串

In [84]: lst = [‘6′,’8′,’3’]

In [85]: print(“\””.join(lst)) 分隔符是双引号,\是转义
6″8″3

 

In [86]: print(” “.join(lst))
6 8 3 空格作为分隔符

In [87]: print(“\n”.join(lst))
6
8
3 换行符作为分隔符

In [88]: lst = [‘1’,[‘x’,’y’],’3′]

In [89]: print(” “.join(lst))
—————————————————————————
TypeError Traceback (most recent call last)
<ipython-input-89-6106afe592ed> in <module>()
—-> 1 print(” “.join(lst))

TypeError: sequence item 1: expected str instance, list found

抛出异常,typeError

 

字符串+连接:
+ ->str
1、将连个字符串连接在一起
2、返回一个新字符串

字符串分割:
1、split系:
将字符串按照分隔符分割成若干个字符串,并返回列表

2、partition系:
将字符串按照分隔符分割成2段,返回这2段和分隔符的元组

 

# split
split(sep=None,maxsplit=-1)-> list of strings
1、从左至右
2、sep指定分割字符串,缺省的情况下空白字符串作为分隔符
3、maxsplit指定分割的次数,-1表示遍历整个字符串
In [1]: s1 = “I’m \ta super man.”

In [2]: s1.split()
Out[2]: [“I’m”, ‘a’, ‘super’, ‘man.’]

 

字符串分割:

一、split系:

将字符串按照分隔符分割成若干个字符串,并返回列表

 

二、partition系:

将字符串按照分隔符分割成2段,返回这2段和分隔符的元组

 

1、split

split(sep=None,maxsplit=-1) -> list for strings

  • 从左至右
  • sep指定分割字符串,缺省的情况下空白作为分割符
  • maxsplit指定分割的次数,-1表示遍历整个字符串

model:

In [1]: s1 = “I’m \ta super man.”

 

In [2]: s1.split()

Out[2]: [“I’m”, ‘a’, ‘super’, ‘man.’]

In [3]: s1.split(‘s’)

Out[3]: [“I’m \ta “, ‘uper man.’]

 

2、rspilt

rsplit(sep=None,maxsplit=-1) -> list of strings

  • 从右向左
  • sep指定分割字符串,缺省的情况下空白字符串作为分隔符
  • maxsplit指定分割次数,-1表示遍历整个字符串

 

 

3、splitlines

splitlines([keepends])->list of strings

  • 按照行来切分字符串
  • keepends指的是是否保留行分隔符
  • 行分隔符包括\n,\r\n,\r等

 

二:partition

1、 partition(sep)->(head,sep,tail)

  • 从左至右,遇到分隔符就把字符串分割成两部分,返回头、分隔符、尾三部分的三元组;如果没有找到分隔符,就返回头、2个空元素的三元组。
  • sep分割字符串,必须指定

 

  • rpartition(sep)->(head,sep,tail)
  • 从右至左,遇到分隔符就把字符串分割成两部分,返回头、分隔符、尾三部分的三元组;如果没有找到分隔符,就返回2个空元素和尾的三元组

 

三、字符串大小写

1、upper():全大写

2、lower():全小写

3、大小写,做判断时候用

4、swapcase():交互大小写

 

 

四、字符串排版

1、title() -> str

标题的每个单词都大写

2、capitalize()-> str

首个单词大写

3、center(width[,fillchar]) -> str

width 打印宽度

fillchar 填充的字符

4、zfill(width)->str

width 打印宽度,局右,左边用0填充

5、ljust(width[,fillchar])-str:左对齐

6、rjust(width[,fillchar])->str:右对齐

 

 

五、字符串修改

1、replace(old,new[,count])->str

字符串中找到匹配替换为新子串,返回新字符串

count表示替换几次,不指定就是全部替换

 

2、strip([chars])->str

从字符串两端去除指定的字符集chars中的所有字符

如果chars没有指定,去除两端的空白字符

lstrip([chars])->str:从左开始

rstrip([chars])-str:从右开始

 

六、字符串查找

1、find(sub[,start[,end]])->int

在指定的区间[start,end),从左至右,查找子串sub。找到返回索引,没有找到返回-1

2、rfind(sub[,start[,end]])

在指定的区间[start,end),从右至左,查找子串sub。找到返回索引,没有找到返回-1

 

3、index(sub[,start[,end]])->int

在指定的区间[start,end],从左至右,查找字符串sub。找到返回索引,没有找到抛出异常ValueError

4、rindex(sub[,start[,end]]) ->int

在指定的区间[start,end],从左至右,查找子串sub。找到返回索引,没有找到抛出异常ValueError。

 

七、时间复杂度

index和count方法都是O(n)

随着列表数据规模的增大,而效率下降

1、len(string)

返回字符串的长度,即字符的个数

2、count(sub[,start[,end]])->int

在指定的区间[start,end],从左至右,统计子串sub出现的次数。

 

八、字符串判断

1、endswith(suffix[,start[,end]])->bool

在指定的区间[start,end],字符串是否是suffix结尾

2、startwith(prefix[,start[,end]])->bool

在指定的区间[start,edn],字符串是否是prefix开头

3、is系列

isalnum()->bool:是否是字母和数字组成

isalpha():是否是字母

isdecimal():是否只包含十进制数字

isdigit():是否全部是数字

isidentifier():是不是字母和下划线开头,其他都是字母、数字、下划线

islower():是否都是小写

isupper():是否全部为大写

isspace():是否只包含空白字符

 

 

九、字符串格式化

字符串的格式化是一种拼接字符串输出样式的手段,更灵活方便

join拼接只能使用分隔符,切被拼接的是可迭代

+拼接字符串还方便,但非字符串需要先转换为字符串才可以

 

format:

格式语法:

format函数格式字符串语法—Python鼓励使用

1、”{}{xxx}”.format(*args,**kwargs)–>str

2、args是位置参数,是一个元组

3、kwargs是关键字参数,是一个字典

4、花括号表示占位符

5、{}表示按照顺序匹配位置参数,{n}表示取位置参数索引为n的值

6、{xxx}表示关键字参数中搜索名称一致的

7、{{}}表示打印花括号

 

a、位置参数:

“{}:{}”.format(‘192.168.1.100’,8888),这就是按照位置参数顺序用位置参数替换前面的格式字符串的占位符

 

b、关键字参数或命名参数

“{server}{1}:{0}”.format(8888,’192.168.0.200’,server=’Web Server Info:’位置参数按照序号匹配,关键字参数按照名词匹配

 

c、访问元素

“{0[0]}.{0[1]}”.format((‘Eric’,’com’))

d、对象属性访问

from collections import namedtuple

Point = namedtuple(‘Point’,’x y’)

p = Point(4,5)

“{{{0.x},{0.y}}}”.format(p)

对齐:

‘{0}*{1}={2:<2}’.format(3,2,2*3) ‘{0}*{1}={2:<02}’.format(3,2,2*3) ‘{0}*{1}={2:>02}’.format(3,2,2*3) ‘{:^30}’.format(‘centered’)

‘{:*^30}’.format(‘centered’)

 

进制:

“int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}”.format(42)

“int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}”.format(42)

octets = [192, 168, 0, 1] ‘{:02X}{:02X}{:02X}{:02X}’.format(*octets)

]]>
/87484/feed 0
Python内置数据结构-list、tuple、string /87482 /87482#respond Sat, 23 Sep 2017 07:03:38 +0000 /87482 Python内置数据结构

分类

  • 数值型
    • int、float、complex、bool
  • 序列对象
    • 字符串 str
    • 列表 list
    • 元组 tuple
  • 键值对
    • 集 set
    • 字典 dict

数值型

  • 数值型
    • int、float、complex、bool都是类(class),1、5.0、1+2j都是对象即实例
    • int:在python3版本中表示长整型,没有大小限制,受限制于内存区域大小
    • float:浮点数由整数部分和小数部分组成,支持十进制和科学计数法表示,在python中只有双精度浮点数
    • complex:复数由实数和虚数部分组成,实数和虚数都是浮点数,例:3+4.2j
    • bool:int的子类,基友两个实例True和False,分别代表1和0,可以直接和整数计算
  • 类型转换
    • int(x) #返回一个整数
    • float(x) #返回一个浮点数
    • complex(x)/comples(x,y) #返回一个复数
    • bool(x) #返回布尔值,对应关系可查看真值表
  • 数字的处理函数
    • python中管与数学处理的模块math需要单独导入(import math),math.floor表示舍去小数部分的值取整,math.ceil表示只要小数位不是零则一律进1
    • int() #将括号内的浮点数小数点后的数值舍掉,只取整数部分
    • round() #这个函数去正式遵循四舍六入,当小数点后为5时,取离得最近的偶数值
    可以测试下如下代码:
    - print(math.ceil(2.1))
    - print(math.floor(2.9))
    - round(2.5)
    - round(3.5)
    - round(3.4)
    - round(3.6)
    
    - min() #取括号内数字的最小值
    - max() #取括号内数字的最打值
    - pow(x,y) #取x的y次方
    - math.sqrt(9) #取就得0.5次方,也就是√-3
    - math.pi #取π的值3.141592653589793
    - math.e #取自然常数的值2.718281828459045
    • 转换进制
      • bin() #转换为二进制字符串
      • oct() #转换位八进制字符串
      • hex() #转换为十六进制字符串
  • 类型判断
    • type(object),返回类型,而不是字符串 例:type(a)、type(‘b’)、type(123) type(1+True+3.0)返回的类型是浮点型,这是应为因为在数学计算中包含一个隐式转换,由精度低的数项精度高的数转换
    • isinstance(obj,class_or_tuple),判断参数是不是后面其中一个的类型,返回布尔值 例:isinstance(6,str) isinstance(6,(str,bool,int,float))

列表(list)

  • 列表的特性
    • 一个队列,排列整齐的队伍
    • 列表里的个体称为元素(item),有若干元素组成
    • 元素可以式任意的数字、字符串、对象、列表等
    • 列表内元素有顺序,可以使用索引
    • 属于线性数据结构
    • 使用[]表示,[]空的中括号表示空列表
    • 列表是可以变化的,可以增、删、改、查和追加
  • 列表list、链表(linklist)、队列(queue)、栈(stack)的差异
    • 列表是有序地,一个接一个排列的集合,每一个元素占据一个单位,就像书本一样,一页内容对应一个页码,可以通过索引来查找
    • 链表是有连接的,一个连一个的,好比手拉手,通过前一个元素可以找到下一个元素
    • 队列可以是列表,也可以是链表,他可以项放行一样先进先出,也可以像解散一样后进先出
    • 栈 是以类似重叠的方式排列,就像摞盘子一样是典型的后进先出队列
  • 列表list定义、初始化
    • list() -> new empty list
    • list(iterable) -> new list initialized from iterable’s items(从可迭代的元素初始化列表)
    • 列表不能一开始就定义大小这是Python中的列表特性,它是可变化的
    • 列表的元素也可以是函数的结果
  • 列表索引访问
    • 索引(index),也叫下标
    • 正索引:从左到右,从0开始,是列表中每一个元素的编号
    • 负索引:从右到左,从-1开始
    • 正负索引不能超超界,超界后报错IndexError
    • 默认认为列表是从左往右排列的,左边头部右边尾部,左边下界右边上界
    • 列表可以通过索引来访问,格式为listname[index],index就是索引,是指某个元素在列表中的位置,默认从0开始
    In [4]: lst
    Out[4]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    
    In [5]:
    
    In [5]: lst[6]
    Out[5]: 6
    
    In [6]:
  • 列表查询
    • index(valiue,[start,[stop]]) 1.通过值value,从指定区间查找列表的元素是否匹配 2.匹配第一个值就返回索引 3.匹配不到,显示valueError
    • count(value) 返回列表中匹配到的值得次数
    • 时间复杂度 1.index和count的方法复杂度是O(n),O(1)这个是表示效率最高,一步操作;count的时间复杂度是O(n)表示所有元素查看一遍或者叫遍历,有n个元素就做n次操作 2.随着数据规模的增大,效率会越来越低
    • 函数len() 查询项目中元素的个数,是公共的内建函数,可以查询类似集合的元素数量
  • 查询帮助
    • 查看帮助文档
    • 查看官方文档
    • 在ipython中通过help(keyword)
      • keyword可以是函数、类、对象、变量、方法名
  • 列表元素修改 当操作修改列表完成时若返回none值则没有新列表生成,是为就地修改
    • 索引访问修改 list[index]=value,索引不能超界,否则就提示异常 -列表增加,插入元素
      1. append(object) #尾部追加,不会生成新的列表,时间复杂度O(1)
      2. insert(index,object) #在指定索引处插入一个值,索引开始到最后的元素整体后移一个单位,索引超下界会在头部追加,超上界尾部追加。由于操作会硬气内存结构的变化,所以一般不使用
      3. extend(iteratable) #列表扩展:将可迭代对象的元素追加进来,就地修改
      4. list1+list2 #连接操作,将两个列表连接起来,产生新表,原列表不变
      5. list*num #重复操作,将本列表元素重复n次,返回新的列表
    • 列表删除元素
      1. remove(value) #从左往右查找第一个匹配的值并移除,就地修改
      2. pop([index]) #不指定索引,从列表哦尾部弹出一个元素,或者制定索引,从指定索引出弹出元素
      3. clear() #清楚对象列表中的所有元素,剩下一个空列表
    • 列表其他操作
      1.reversed() #将列表中元素颠倒顺序,就地修改
      2.sort(key=None,reverse=False) #对列表惊醒排序,就地修改,默认升序;reverse=True,就是反转并按降序排列;key可以制定一个函数,指定key如何排序
      3. in 查看一个元素在不在一个列表中;而for x in [1,2,3,4]表示从列表中取出元素附给x
  • 列表复制
  • copy() #shadown cpoy(影子复制),也叫浅拷贝,遇到引用类型,只是复制了一个引用,如果引用的对象被修改,则两个列表所引用的元素都会改变,
  • 深拷贝,copy模块提供深拷贝,深copy会在内存中新建一个列表,并赋值

随机数

random模块 1.random.randint(a,b) #返回[a,b]之间的整数 2.random.choice(seq) #从非空序列中随机挑选一个元素 3.randrange([start,]stop[,step]) #从指定按制定奇数递增的集合中获取一个随机数,默认奇数为1 4.random.shuffle(list) #就地打乱列表元素

练习

1.求100内的素数

lst=[2]
for i in range(3,100,2):
    for n in lst:
        if i%n ==0:
            break
    else:
        #print(i)
        lst.append(i)   #将计算出的素数追加到素数列表中
print(lst)

import math 
pn=[]
for x in range(3,1000,2):
    for i in pn:
        if x%i==0:
            sign=True
            break
        if i>=math.ceil(x**0.5):
            sign=False
            break
    if not sign:   #只有是真值的时候,才会执行及里边的语句块,当flag为Falsenot flag是True,程序才会进去if内部语句块,否则就继续下面的语句
        #print(x)
        pn.append(x)
print(pn)

2.计算杨辉三角的前六行

triangle=[[1],[1,1]]
for i in range(2,6):
    p = triangle[i-1]
    cur=[1]
    for j in range(0,i-1):
        cur.append(p[j]+p[j+1])
    cur.append(1)
    triangle.append(cur)
print(triangle)

triangle=[]
for i in range(6):
    if i==0:
        lr=[1]
        triangle.append(lr)
    else:       
        p=triangle[i-1]
        cur=[1]
        for j in range(0,i-1):
            cur.append(p[j]+p[j+1])
        cur.append(1)
        triangle.append(cur)
print(triangle)

triangle=[]
for i in range(6):
    if i==0:
        lr=[1]
        triangle.append(lr)
    else:
        p=[0]
        p.extend(triangle[i-1])
        p.append(0)
        cur=[]
        for j in range(0,i+1):
            cur.append(p[j]+p[j+1])
        triangle.append(cur)
print(triangle)

triangle=[]
for i in range(6):
    if i==0:
        lr=[1]
        triangle.append(lr)
    elif i==1:
        lr=[1,1]
        triangle.append(lr)        
    else:       
        p=triangle[i-1]
        cur=[1]
        x=1
        while x<=(i-1):
            cur.append(p[x-1]+p[x])
            x+=1
        cur.append(1)
        triangle.append(cur)
print(triangle)

方法二

ol=[]
nl=[1]
print(nl)
for i in range(1,6):
    ol=nl.copy()
    ol.append(0)
    nl.clear()
    offset=0
    while offset<=i:
        nl.append(ol[offset-1]+ol[offset])
        offset+=1
    print(nl)

元组(tuple)

元组是一个有序的元素组成的集合,使用()表示,元组是不可变对象,包括元祖的的长度和元素本身。如果元祖中的元素是一个引用对象,当引用对象本身发生变化是,元组中的元素才会发生变化。

  • 定义
    • tuplename=tuple() #定义一个空元组,括号里可以是可迭代对象、数字、字符串、列表等
    • tuplename=tuple(2,) #当定义一个元素的元组时,要在元素后加个逗号,否则会提示括号所在的类不是一个可迭代对象
    • tuple和list一样,可以使用‘+’连接两个不同的元组,创建一个新的元组打印出来,也可以通过‘*’创建一个被乘的元组重复几次的新元组打印出来。
    • 元祖也支持索引访问,包括正负索引,其访问的方式和列表一样,但是索引不能超界,否则引发异常
    • tuplename.index(9) #在tuplename这个元组中查看9的索引,会返回从左到右最近的匹配到的9的索引,匹配不到就返会valueerror。
    • tuplename.count(9) #在tuplename这个猿族中查询9这个值在元组中出现了几次
    • len(tuplename) #查询元祖的长度或者说是元组中元素的个数
    • 元组类似于只读权限的文件,这可以读取,不能增改删,只能删除整个元组
  • 命名元组namedtuple
    • namedtuple使用时需要执行命令“from collections import namedtuple”
    • namedtuple(typename,field_names(可以是空格或者逗号分隔的字段的字符串,也可以是字段的列表),verbose=FaLse,rename=False) #命名元组,返回元组的子类,并定义字段 例: “` In [2]: from collections import namedtuple
      In [3]: Point=namedtuple('_Point',['x','y'])
      
        In [4]: p=Point(11,22)
      
        In [5]: p.x
        Out[5]: 11
      
        In [6]: p.y
        Out[6]: 22
      
        ```
  • 练习
    • 以此接收用户输入的3个数,排序后打印
      1. 转换int后,判断大小排序
      2. 使用max函数
      3. 使用列表的sort方法
      4. 冒泡法

字符串

字符串是有序的字符集合或者称字符序列,支持使用索引访问,是一个可迭代的对象

  • 字符串join连接 python种特殊字符需要转义后使用
    例:
    In [15]: lst
    Out[15]: ['1', '2', '3']
    
    In [16]: print('/'.join(lst))
    1/2/3
    
    In [17]: print('\\'.join(lst))
    1\2\3
    
    In [18]: print('"'.join(lst))
    1"2"3
    • 连接符 和列表的用法一样,在这里是将两个字符串连接到一起返回一个新字符串
  • 字符串分割 1.split系:将字符分割成若干字符串,并返回列表。
    格式
    - (string's name).split(sep=None,maxsplit=-1)
    分割时时从左向右sep制定分割字符串,默认时空白字符串作为分隔符;maxsplit制定分割次数,-1表示便利整个字符串。
    - (string's name).rsplit(sep=None,maxsplit=-1)
    从右向左
    - (string's name).splitlines([keepends])
    按照行来切分字符串,keepends指的是是否保留行分隔符(\n、\r\n、\r等)

    2.partittion系:将字符串按照分隔符分成两段,放回这两段和分割符的元组

    - partition(sep(必须指定))
        从左到右,遇到分隔符就把字符串分成两部分,返回头(head)、分隔符、尾(tail)三部分的三元组;如果没有找到分隔符,就返回头、2个空元素的三元组
    - rpartition(sep)
        从右到左,功能同上
  • 字符串大小写
    • upper() 全大写
    • lower() 全小写
    • swapcase() 交互大小写,就是大写变小写,小写变大写。
  • 字符串排版
    • title 标题的每个单词首字母大写
    • capitalize 第一个单词首字母大写
    • center(width[,fillchar]) 打印字符串时居中打印,用多少个字符的宽度如果字符串不够用某个字符填充,默认字符是空格
    • zfill(width) 右对齐打印,左边字符不够的用0填充
    • ljust/rjust(width[,fillchar]) 左/右对齐打印
  • 字符串修改
    - replace(old,new[,count]) 替换
        在字符串中找到指定字符串,替换为新字符串,返回新字符串,count表示替换几次
    - strip([chars]) 去除
        从字符串两端去除指定字符集chars中的所有字符串,如果chars没有指定则去除空白字符,同样有两种变体:lstrip/rstrip 从左/右开始去除
    - find(sub[,start[,end]]) 查找字符串
        在指定区间从左到右查找子串sub,找到则返回索引,没有就返回-1
        变体rfind:从右到左查找
    - index(sub[,start[,end]])  查找字符串
        在指定区间从左到右查找子串sub,找到则返回索引,没有就返回ValueError
        变体rindex:从右到左查找
    - count(sub[,start[,end]]) 统计
        在指定区间从左到右统计子串sub出现的次数
    - endwith/startwith([char,start[,end]]) 字符串判断
        在指定的区间中,字符串是否以指定的字符串开头或者结尾,返回bool值
    - ismetacharacters() 判断字符串有那些字符组成
        metacharacters可以时alpha、numdecimal、digit、dentifier、lowerupperspace
  • 字符串格式化 字符串格式化是指将字符串以特定的输出样式输出的书法
  1. join连接只能使用分隔符,但是连接的对象必须是可迭代对象
  2. ’+‘连接字符串比较方便,但是只能连接字符串
  • printf style
    在python2.5版本之前只能使用printf style(C语言风格)的方式来格式化
    格式要求
        占位符,使用%和格式字符组成
            1.s掉用str()表示字符串;r调用repr(),表示对象通过repr函数转换为字符串;d调用int(),表示数字
            2. 占位符中汗可以插入修饰字符,例如%03d表示打印的字符站三个字符的位置,不够的前面用0补齐
  • python自用的格式化字符串的语法
    '{}{xxx}'.format(*args,*kwargs)
            1. args是位置参数,是个元组
            2. kwargs是关键字参数,是个字典
            3. 大括号表示占位符
            4. {}表示按照顺序匹配位置参数,{n}表示取位置参数索引n的值
            5. {{}}表示打印大括号
            6. {xxx}表示在关键字仲搜索名称一致的
            7. {lst[0]}表示访问对象元素
            8. {p.x}表示对象属性访问
        例:
        '{}:{}'.format('192.168.1.100',8888)  按位置参数匹配
        '{server}{1}:{0}'.format(8888,'192.168.1.100',server='Webserver') 匹配关键字参数或命名参数
        对齐
        '{0}*{1}={2:<2}'.format(3,2,3*2)
        '{0}*{1}={2:<02}'.format(3,2,3*2)
        '{0}*{1}={2:>02}'.format(3,2,3*2)
        '{:^30}'.format('Internet Data Center') 表示占用30个字符居中对齐,不够的用空白字符填充
        '{=:^30}'.format('Internet Data Center')  表示占用30个字符居中对齐,不够的用=字符填充
        进制转换
        '{0:d/x/o/b/X}'.format(99)   d表示十进制,x/X表示十六进制小/大写,o表示八进制,b表示二进制

练习

  • 用户输入一个数字
    • 判断是几位数
    • 打印每一位数重复次数
    • 按照个十百千万顺序打印每一位上的数字
num=''
while True:
    num=input('Enter:').strip()
    if num.isdigit():
        break
    else:
        print('please Enter number')

count=[0]*10

for i in range(10):
    count[i]=num.count(str(i))
for i in range(10):
    if count[i]:
        print(i,count[i])
lst=list(num)
lst.reverse()
print(lst)
  • 输入五个数字,打印每个数字的位数,将这些数字按升序排列打印
列表排序
n=''
lst=[]
wsl=[]
c=0
while c<=4:
    n=input('Enter:')    
    lst.append(int(n))
    wsl.append(len(n))
    c+=1
print(wsl)
lst.sort()
print(lst)
]]>
/87482/feed 0
第二十二周作业 /81786 /81786#respond Sat, 23 Sep 2017 02:37:52 +0000 /?p=81786 1、请描述本地文件系统和分布式文件系统的特点;

本地文件系统:

本地文件系统主要是指Ext2,Ext3,Btrfs,XFS这类(很难概括,只好举例子),它们通常提供以下功能:

1.扩展性:随着系统容量的增加保持性能,不随容量变化而导致性能震荡。比如一个目录下的海量文件,在EXT2/3中由于目录设计问题会导致较大的性能问题。再比如EXT2/3中的Metadata的占用和inode的划分可能会导致空间的浪费。

2.数据一致性
1)Checksum: Checksum与对应的数据块分开放置,避免silent corruption
2)CoW事务: 写时复制
3)Log: Log被一些文件系统用作WAL模式来加快写操作,并且保证写操作的原子性

3.多设备管理:传统上Linux往往使用LVM进行多设备的管理,现代文件系统往往增加对多设备的支持。如ZFS和Btrfs会有存储池模型对应LVM的逻辑卷组,文件系统会对底层的多设备进行并行的访问。
1)快照和克隆:采用COW事务模型的文件系统通常具有这个特性
2)软件RAID支持:现代文件系统通过对多设备的管理可以很好的支持软件RAID,如Btrfs对Metadata进行RAID1的默认保护

4.针对SSD的优化: 除了SSD对于随机读这一特性的优化外,还有对SSD擦除操作的优化。另外,SSD在使用容量接近100%时会导致极差的写入性能,文件系统也可以对SSD的分配策略和重平衡进行一定的优化。

5.压缩和加密: 现在的IO速度远远跟不上CPU的发展,因此对磁盘文件进行压缩读写是个很好的选择,现代文件系统往往支持多种压缩格式,而且可以支持整个文件系统的加密或者某个文件和目录的加密

6.去重: 文件系统系统去重是个大话题,主要是计算块的checksum方法或者客户端计算文件的hash来决定是否是一个新文件。具体参考Deduplication。

本地文件系统架构图:

分布式文件系统:

分布式文件系统的架构和实现有非常大的差异,如NFS这种传统的基于存储服务器的网络文件系统,基于SAN的GPFS,然后现在的集群式架构,比如HDFS这种有中心的分布式,如GlusterFS这种无中心分布式,再如Ceph这种部分在内核态部分在用户态等等。
由于架构上的差异和本身文件系统的设计目标,通常分布式文件系统可以根据接口类型分成块存储、对象存储和文件存储。如Ceph具备块存储(Experiment)、文件存储和对象存储的能力,GlusterFS支持对象存储和文件存储的能力。而MogileFS只能作为对象存储并且通过key来访问。

1.扩展能力: 毫无疑问,扩展能力是一个分布式文件系统最重要的特点。分布式文件系统中元数据管理一般是扩展的重要问题,GFS采用元数据中心化管理,然后通过Client暂存数据分布来减小元数据的访问压力。GlusterFS采用无中心化管理,在客户端采用一定的算法来对数据进行定位和获取。

2.高可用性: 在分布式文件系统中,高可用性包含两层,一是整个文件系统的可用性,二是数据的完整和一致性。整个文件系统的可用性是分布式系统的设计问题,类似于NOSQL集群的设计,比如有中心分布式系统的Master服务器,网络分区等等。数据完整性则通过文件的镜像和文件自动修复等手段来解决,另外,部分文件系统如GlusterFS可以依赖底层的本地文件系统提供一定支持。

3.协议和接口: 分布式文件系统提供给应用的接口多种多样,Http RestFul接口、NFS接口、Ftp等等POSIX标准协议,另外通常会有自己的专用接口。

4.弹性存储: 可以根据业务需要灵活地增加或缩减数据存储以及增删存储池中的资源,而不需要中断系统运行。弹性存储的最大挑战是减小或增加资源时的数据震荡问题。

5.压缩、加密、去重、缓存和存储配额: 这些功能的提供往往考验一个分布式文件系统是否具有可扩展性,一个分布式文件系统如果能方便的进行功能的添加而不影响总体的性能,那么这个文件系统就是良好的设计。这点GlusterFS就做的非常好,它利用类似GNU/Hurd的堆栈式设计,可以让额外的此类功能模块非常方便的增加。

MogileFS/FastDFS架构图:

2、总结常用的分布式文件系统的应用场景及常规的维护方式;

名称 适用场景
MogileFS 适用于处理海量小文件
Ceph PB级的分布式文件系统
MooseFS 适用于处理海量小文件
Taobao Filesystem 适用于处理海量小文件
GlusterFS 适于用处理单个大文件
Google Filesystem 适用于处理单个大文件
Hadoop Distributed Filesystem 适用于处理单个大文件

3、从理论原理到实战案例来阐述MogileFS体系;

Tacker’s Database(数据库)
数据库保存了Mogilefs的所有元数据,你可以单独拿数据库服务器来做,也可以跟其他程序跑在一起,数据库 部分非常重要,类似邮件系统的认证中心那么重要,如果这儿挂了,那么整个Mogilefs将处于不可用状态。因此最好是HA结构。

Storage nodes(存储节点)
mogstored 程序的启动将使本机成为一个存储节点。启动时默认去读/etc/mogilefs/mogstored.conf 。mogstored启动后,便可以通过mogadm增加这台机器到cluster中。一台机器可以只运行一个mogstored作为存储节点即可,也可以同时运行其他程序。

Trackers(跟踪器)
mogilefsd即 trackers程序,类似mogilefs的wiki上介绍的,trackers做了很多工作,Replication ,Deletion,Query,Reaper,Monitor等等。mogadm,mogtool的所有操作都要跟trackers打交 道,Client的一些操作也需要定义好trackers,因此最好同时运行多个trackers来做负载均衡。trackers也可以只运行在一台机器 上,也可以跟其他程序运行在一起,只要你配置好他的配置文件即可,默认在/etc/mogilefs/mogilefsd.conf。

工具
主要就是mogadm,mogtool这两个工具了,用来在命令行下控制整个mogilefs系统以及查看状态等等。

Client
Client实际上是一个Perl的pm,可以写程序调用该pm来使用mogilefs系统,对整个系统进行读写操作。

原理:
每次文件的上传和读取,都经过前端Trackers服务器,trackers服务器收到client端的请求,查询数据库,返回一个上传或者是读取的可用的后端StorageNode的地址,然后由client端直接操作后端StorageNode服务器。upload操作返回就是成功或者失败的结果,read操作就是返回对应的查询数据。

 

环境:

Tracker + Tracker database:192.168.0.21

Mogstored node1:192.168.0.22

Mogstored node2:192.168.0.23

 

 

### 安装包
~]# ls mogilefs
MogileFS-Server-2.46-2.el6.noarch.rpm            Perlbal-doc-1.78-1.el6.noarch.rpm
MogileFS-Server-mogilefsd-2.46-2.el6.noarch.rpm  perl-MogileFS-Client-1.14-1.el6.noarch.rpm
MogileFS-Server-mogstored-2.46-2.el6.noarch.rpm  perl-Net-Netmask-1.9015-8.el6.noarch.rpm
MogileFS-Utils-2.19-1.el6.noarch.rpm             perl-Perlbal-1.78-1.el6.noarch.rpm
Perlbal-1.78-1.el6.noarch.rpm

### 在tracker和mogstored节点上安装需要的包
~]# cd mogilefs
~]# yum install * -y

### 在tracker节点上安装mysql
~]# yum install mysql-server -y
~]# vim /etc/my.cnf
[mysqld]
...
innodb_file_per_table=ON
skip_name_resolve
~]# /etc/init.d/mysql start
mysql> CREATE DATABASE mogdb charset utf8;
mysql> grant all on mogdb.* to 'moguser'@'192.168.0.%' identified by 'mogpass';
mysql> flush privileges;

### 初始化mogdb库
~]# mogdbsetup --dbname=mogdb --dbuser=moguser --dbpass=mogpass
This will attempt to setup or upgrade your MogileFS database.
It won't destroy existing data.
Run with --help for more information.  Run with --yes to shut up these prompts.

Continue? [N/y]: y

Create/Upgrade database name 'mogdb'? [Y/n]: y

Grant all privileges to user 'moguser', connecting from anywhere, to the mogilefs database 'mogdb'? [Y/n]: y

### 修改配置文件
~]# vim /etc/mogilefs/mogilefsd.conf
db_dsn = DBI:mysql:mogdb:host=192.168.0.61
db_user = moguser
db_pass = mogpass
listen = 0.0.0.0:7001

### 启动tracker###
~]# /etc/init.d/mogilefsd start

### 在mogstored节点1创建数据挂载点
mkdir -p /data/mogstored/DEV{1,2}
chown -R mogilefs.mogilefs /data/mogstored/
### 在mogstored节点2创建数据挂载点
mkdir -p /data/mogstored/DEV{3,4}
chown -R mogilefs.mogilefs /data/mogstored/

### 修改mogstored配置文件
vim /etc/mogilefs/mogstored.conf
maxconns = 10000
httplisten = 0.0.0.0:7500
mgmtlisten = 0.0.0.0:7501
docroot = /data/mogstored                  #修改数据文件目录为实际路径

### 启动mogstored服务
/etc/init.d/mogstored start

### 在tracker上创建host
~]# mogadm host add 192.168.0.62 --ip=192.168.0.62 --port=7500 --status=alive
~]# mogadm host add 192.168.0.63 --ip=192.168.0.63 --port=7500 --status=alive
### 创建device
~]# mogadm device add 192.168.0.62 1       #最后的数字代表设备号,如:dev1
~]# mogadm device add 192.168.0.62 2
~]# mogadm device add 192.168.0.63 3
~]# mogadm device add 192.168.0.63 4
### 查看device状态
~]# mogadm device list
192.168.0.62 [1]: alive
                    used(G)    free(G)   total(G)  weight(%)
   dev1:   alive      1.643    108.021    109.664        100
   dev2:   alive      1.643    108.021    109.664        100

192.168.0.63 [2]: alive
                    used(G)    free(G)   total(G)  weight(%)
   dev3:   alive      1.643    108.021    109.664        100
   dev4:   alive      1.643    108.021    109.664        100

### 创建一个名为files的域用来存储文件
~]# mogadm domain add files

### 将本地的/etc/fstab文件上传至files域,并命名为fstab.txt
~]# mogupload --trackers=192.168.0.61 --domain=files --key='/fstab.txt' --file='/etc/fstab'
### 查看files域中的文件
~]# moglistkeys --trackers=192.168.0.61 --domain=files
/fstab.txt
### 查看已上传的fstab.txt文件的属性信息
~]# mogfileinfo --trackers=192.168.0.61 --domain=files --key='/fstab.txt'
- file: /fstab.txt
     class:              default
  devcount:                    2
    domain:                files
       fid:                    3
       key:           /fstab.txt
    length:                  805
 - http://192.168.0.62:7500/dev1/0/000/000/0000000003.fid
 - http://192.168.0.63:7500/dev3/0/000/000/0000000003.fid

 ### 下载fstab.txt文件到本地,并另存为fstab_dfs.txt
 ~]# mogfetch --trackers=192.168.0.61 --domain=files --key='/fstab.txt' --file='/tmp/fstab_dfs.txt'

 

 

4、自动化运维工具ansible的应用示例

 

1.安装ansible
~]# yum install ansible -y

 

2.修改配置文件,添加客户端信息
~]# vim /etc/ansible/hosts
[websrvs] #组名称可以自定义
192.168.0.121
192.168.0.131
192.168.0.141

 

3.与客户端建立ssh公钥认证(免密登录)
~]# ssh-copy-id -i ~/.ssh/id_rsa.pub root@192.168.0.121
~]# ssh-copy-id -i ~/.ssh/id_rsa.pub root@192.168.0.131
~]# ssh-copy-id -i ~/.ssh/id_rsa.pub root@192.168.0.141

 

4.使用ping模块进行ping测试
~]# ansible websrvs -m ping

 

5.使用command模块远程执行命令(此模块不支持管道符)
#在目标主机上创建user1用户
~]# ansible websrvs -m command -a “useradd user1”

 

6.使用shell模块远程执行命令(此模块支持管道符)
#在目标主机上修改user1用户的密码
~]# ansible websrvs -m shell -a “echo “mageedu”|passwd –stdin user1”

 

7.使用copy模块将本地文件远程复制到目标主机
#将本地的/tmp/hello.txt文件copy到目标主机的/tmp目录下
~]# ansible websrvs -m copy -a “src=/tmp/hello.txt dest=/tmp”

#将content中的字符串copy到目标主机的/tmp/hello.txt文件下,如果该文件已存在,将会覆盖原文件内容
~]# ansible websrvs -m copy -a “content=’my name is mageedu\n’ dest=/tmp/hello.txt”

 

8.使用cron模块远程设置计划任务
#在目标主机上创建一个名为Synctime的计划任务,用来做时间同步
~]# ansible websrvs -m cron -a “minute=*/5 job=’/usr/sbin/ntpdate cn.pool.ntp.org &>/dev/null’ name=Synctime”

#删除上面创建的Synctime计划任务
~]# ansible websrvs -m cron -a “state=absent name=Synctime”

 

9.使用file模块远程修改文件权限
#修改目标主机上的/tmp/hello.txt文件的权限
~]# ansible websrvs -m file -a “path=/tmp/hello.txt owner=root group=root mode=777”

 

10.使用yum模块远程安装软件包
#在目标主机上yum安装apache
~]# ansible websrvs -m yum -a “name=httpd state=latest”

 

11.使用service模块远程启停服务
#在目标主机上启动httpd服务
~]# ansible websrvs -m service -a “name=httpd state=started”

 

12.使用user模块远程管理用户
#在目标主机上创建系统帐号user2,uid为306
~]# ansible websrvs -m user -a “name=user2 system=yes state=present uid=306”

#删除上面创建的用户
~]# ansible websrvs -m user -a “name=user2 system=yes state=absent”

]]>
/81786/feed 0
集中练习3 /87471 /87471#respond Wed, 20 Sep 2017 09:51:52 +0000 /87471 (1) 显示当前系统上root、fedora或user1用户的默认shell
“`
~]# grep -E “^(root|fedora|user1)” /etc/passwd | cut -d: -f7
/bin/bash
/bin/bash
/bin/bash
“`
(2) 找出/etc/rc.d/init.d/functions文件中某单词后面跟一组小括号的行,形如:hello();
“`
~]# grep -E “[[:alpha:]]+\(\)” /etc/rc.d/init.d/functions
checkpid() {
__kill_pids_term_kill_checkpids() {
__kill_pids_term_kill() {
__pids_var_run() {
__pids_pidof() {
daemon() {
killproc() {
pidfileofproc() {
pidofproc() {
status() {
echo_success() {
echo_failure() {
echo_passed() {
echo_warning() {
update_boot_stage() {
success() {
failure() {
passed() {
warning() {
action() {
strstr() {
is_ignored_file() {
is_true() {
is_false() {
apply_sysctl() {
“`
(3) 使用echo命令输出一个绝对路径,使用grep取出其基名;扩展:取出其路径名
“`
~]# echo “/etc/sysconfig/network-scripts/ifcfg-ens33” | grep -Eo “[^/]+/?$” | cut -d’/’ -f1
ifcfg-ens33
~]# echo “/etc/sysconfig/network-scripts/ifcfg-ens33” | grep -Eo “^/.*/”
/etc/sysconfig/network-scripts/
“`
(4) 找出ifconfig命令结果中的1-255之间的数字
“`
~]# ifconfig | grep -E “(\<[1-9]\>|\<[1-9][0-9]\>|\<1[0-9][0-9]\>|\<2[0-4][0-9]\>|\<25[0-5]\>)”
“`
(5) 挑战题:写一个模式,能匹配合理的IP地址
“`
~]# ifconfig | grep -E “(\<[1-9]\>|\<[1-9][0-9]\>|\<1[0-9][0-9]\>|\<2[0-4][0-9]\>|\<25[0-4]\>).(\<[0-9]\>|\<[1-9][0-9]\>|\<1[0-9][0-9]\>|\<2[0-4][0-9]\>|\<25[0-4]\>).(\<[0-9]\>|\<[1-9][0-9]\>|\<1[0-9][0-9]\>|\<2[0-4][0-9]\>|\<25[0-4]\>).(\<[1-9]\>|\<[1-9][0-9]\>|\<1[0-9][0-9]\>|\<2[0-4][0-9]\>|\<25[0-4]\>)”
inet 10.6.9.148 netmask 255.255.255.0 broadcast 10.6.9.255
inet 127.0.0.1 netmask 255.0.0.0
inet 192.168.122.1 netmask 255.255.255.0 broadcast 192.168.122.255
“`
(6) 挑战题:写一个模式,能匹配出所有的邮件地址
“`
~]# vim mail.test
tom@cartoon.com hello
13810773388@139.com —o9fkdjfi#
sssjji4f4e@126.com jfeifj389j
hhd8-12dd@hh99-jd.net jjjjllllll

~]# grep -Eo “\<[[:alnum:][:punct:]]+@[[:alnum:][:punct:]]+.[[:alpha:]]\>” mail.test
tom@cartoon.com
13810773388@139.com
sssjji4f4e@126.com
hhd8-12dd@hh99-jd.net
“`
(7) 查找/var目录下属主为root,且属组为mail的所有文件或目录
“`
~]# find /var -user root -a -group mail
/var/spool/mail
/var/spool/mail/root
“`
(8) 查找当前系统上没有属主或属组的文件;扩展:查找当前系统上没有属主或属组,且最近三天内曾被访问过的文件或目录;
“`
~]# find / -nouser -o -nogroup -a -type f
扩展:
~]# find / -nouser -o -nogroup -a atime -3
“`
(9) 查找/etc目录下所有用户都有写权限的文件
“`
~]# find /etc -perm -222 -a -type f
“`
(10) 查找/etc目录下大于1M,且文件类型为普通文件的所有文件
“`
~]# find /etc -size +1M -type f -exec ls -lh {} \;
-rw-r–r–. 1 root root 3.6M Nov 12 2016 /etc/selinux/targeted/active/policy.kern
-rw-r–r–. 1 root root 1.4M Nov 12 2016 /etc/selinux/targeted/contexts/files/file_contexts.bin
-rw-r–r–. 1 root root 3.6M Nov 12 2016 /etc/selinux/targeted/policy/policy.30
-r–r–r–. 1 root root 7.0M Aug 29 14:42 /etc/udev/hwdb.bin
-rw-r–r–. 1 root root 1.4M Nov 6 2016 /etc/brltty/zh-tw.ctb
“`

]]>
/87471/feed 0
友情链接:万达娱乐招商  万达主管  guoqibee.com  万达招商  万达娱乐直属  万达娱乐主管QQ  guoqibee.com  万达娱乐直属QQ  万达娱乐开户  万达主管QQ