Python的学习记录2

python

---

序列

1.列表：可以一次性存储多个数据，且可以为不同数据类型

列表的创建

1. a = [value1,value2,value3…]
2. list()创建

a = list()  => 空列表
a = list("abc") => [a,b,c]

3. range()创建整数列表

range[start,end,step]
start :可选，表示起始数字，默认为0
end   :必选，表示结尾数字
step  :可选，表示步长，默认为1

a = list(range(10)) => [0,1,2,3,4,5,6,7,8,9]
a = list(range(3,10,2) => [3,5,7,9]
a = list(range(10,3,-1)) => [9,7,5,3]

4. 推导式创建（和循环判断结合）

a = [x*2 for x in range(5)] => [0,2,4,6,8]
a = [x*2 for x in range(5) if x%3 == 0] => [0,6]

列表元素的增加和删除

1. append() 在元素尾部加东西

a = [20,40]
a.append(80)
print(a) => [20,40,80]

2. extend() 在尾部增加列表

a = [20,40]
b = [5,40]
a.extend(b)
print(a) => [20,40,5,40]

3. insert() 插入元素

a = [30,40]
a.insert(0,100)
a => [100,30,40]

列表元素的删除

1. del 删除

a=[20,30,40]
del a[0]
a => [30,40]

2. pop() 删除并返回指定元素，未指定默认最后一个元素

a = [20,40,50]
b = a.pop()
b => 50
c = a.pop(0)
c => 20

3. remove() 删除首次出现的元素，不存在则表示异常

a = [10,20,30,20,40,50]
a.remove(20)
a => [10,30,20,40,50]

列表元素的访问

1. 通过下标

a = [20,30,40]
a[0] =>20

2. index() 获得指定元素在列表中首次出现的索引
   语法：index(value,start,end) :表示寻找value在start end这个范围里

a = [10,20,30,20,40,50]
a.index(20)
a => 1
b = [10,20,30,20,40,50]
b.index(40,0,5)
b => 4

3. 列表中判断是否存在的函数
   1. in:判断指定数据在某个列表序列，如果在返回True，否则返回False
   2. not in ：判断指定数据不在某个列表序列，如果不在返回True，否则返回False

a = [10,20,30,20,40,50]
20 in a
True
100 not in a
True

4. len() count() sum() max() min() len获取长度，count计数sum()求和 max()找出最大值 min()找最小值

a = [10,20,30,20,40,50]
b = len(a)
b => 6
c =count(50)
c => 1
d = sum(a)
d => 170
e = max(a)
e => 50

切片操作（slice）和字符串的使用一样

a = [10,20,30,20,40,50]
a[:] => [10,20,30,20,40,50]
a[2:5] => [30,20,40]
a[-3:] => [20,40,50]
a[::-1] => [50,40,20,30,20,10]

列表的排序

a = [10,20,30,20,40,50]
a.sort()  #默认升序排列
a => [10,20,20,30,40 50]

a.sort(reverse = True) #降序排列
a => [50,40,30,20,20,10]

a = [10,20,30,20,40,50]
b = sorted(a) #默认升序 生成一个新列表
b =>[10,20,20,30,40 50]

多维列表

a = [
		["troke",10000,"Cool"]
		["tro",10000,"easy"]
		["ke",10000,"good"]
    ]

2.元祖(tuple) :不可变序列

元祖的创建

1. 通过()创建 ，小括号可以省略
   如果只有一个元素，则后面必须加，号

a =(1,2,3)
a => 1,2,3
a =(1,)
a => 1

2. 通过tuple()创建

a = tuple()
b = tuple("abc")
c = tuple(range(3))
d = tuple([2,3,4])
相当于强制转换

3. 通过生成器推导

s = (x for x in range(5))
tuple(s) => (0,1,2,3,4,5) #只能使用一次
tuple(s) => ()

3. 元祖的元素不能修改

1. 访问

a = tuple("abc")
a[0] => a

2. 切片和列表的方式一样
3. 元祖的排序 只能用sorted()函数来进行
4. len() count() sum() max() min() len获取长度，count计数sum()求和 max()找出最大值 min()找最小值

字典

字典是"键值对"的无序可变序列类似与C语言中的结构体，区别在于字典定义时直接赋值 访问的方式和结构体类似

字典的创建

1. 利用{}创建

a ={'name':'troke','age':18,'where':'shenzhen'}

2. 利用dict()创建

a = dict('name'='troke','age'=18,'where'='shenzhen')
a = dict([('name','troke'),('age','18')]) #和列表元祖结合

3. 通过zip()创建

a = ['name','age','where']
b = ['troke' ,'18','shenzhen']
c =dict(zip(a,b))
c => {'name':'troke','age':18,'where':'shenzhen'}

字典元素的访问

1. 通过[键]去获得值

a ={'name':'troke','age':18,'where':'shenzhen'}
a['name']

2. 通过get()方法获得值，不存的元素返回None

a ={'name':'troke','age':18,'where':'shenzhen'}
a.get('name') => troke

3. items() 列出所有的键值对

a ={'name':'troke','age':18,'where':'shenzhen'}
a.items() => dict_items([('name','troke'),('age','18'),('where','shenzhen')])

4. key() 列出所有的对

a ={'name':'troke','age':18,'where':'shenzhen'}
a.key() => dict_key(['name','age','where'])

5. values() 列出所有的值

a ={'name':'troke','age':18,'where':'shenzhen'}
a.values() => dict_value(['troke',18,'shenzhen'])

字典元素的添加，删除，修改

1. 添加

• 直接添加 如果键已存在原先的会给覆盖

a ={'name':'troke','age':18,'where':'shenzhen'}
a['country']='China'
a => {'name':'troke','age':18,'where':'shenzhen','country':China}
a['age']=19
a => {'name':'troke','age':19,'where':'shenzhen','country':China}

• 使用update()

a ={'name':'troke','age':18,'where':'shenzhen'}
b ={'name':'kep','age':19,'country':'China'}
a.update(b)
a => {'name':'kep','age':19,'where':'shenzhen''country':'China'}

2. 删除

• 使用del

a ={'name':'troke','age':18,'where':'shenzhen'}
del(a['name'])
a => {'age':18,'where':'shenzhen'}

• 使用pop删除指定键值对并返回对应的值对象

a ={'name':'troke','age':18,'where':'shenzhen'}
b = a.pop('name')
b => 'troke'

更多例子

dict1  = {1:'one',2:'two',3:'three',4:''}
print(dict1)
dict1[4] = 'forth'
print(dict1)
# 通过键名来获取值
print(dict1[1])
print(dict1[2])
print(dict1[3])

# 字典的一些方法
# 通过get方法 get(k:_KT),当索取一个不存在键时不会报错返回None 也可以自己定义
print(dict1.get(1))
print(dict1.get(6))
print(dict1.get(6),'没有此键名')

# fromkeys() 两个参数 iterable(可迭代的值)，values(值)
dict2 = {}
dict2 = dict2.fromkeys((1,2,3),'one')
dict2 = dict2.fromkeys(range(10),'key')
print(dict2)

# 通过 keys()方法来获取字典所有的键
print(dict1.keys())

# 通过 values()方法来获取字典所有的值
print(dict1.values())

# 通过 items() 方法来获取字典所有的键值对
print(dict1.items())


# 通过pop() 删除键值
print(dict1.pop(4))
print(dict1)

# 通过del 删除字典的值
del(dict1[3])
print(dict1)

# 通过clear()清空字典里的所有的健值对
print(dict1.clear())
print(dict1)

序列解包

用于元祖、列表、字典，方便赋值

(x,y,z)=(20,30,40) #元祖
[ x,y,z ]=[20,30,40] #列表

#对字典
a ={'name':'troke','age':18,'where':'shenzhen'}
name,age,where = a #默认对键进行操作
name => 'name' age => 'age'
#获得值
name,age,where =a.values()
name => 'troke'

集合

集合是无序可变，元素不能重复，其所有元素都是字典中的“键对象”

集合的一些操作

a={1,2,3}
a => {1,2,3}
a.add(9) #添加元素
a => {1,2,3,9}

#利用set()，将列表，元祖等转换成集合
a =list(a,b,c)
b =set(a)
b => {a,b,c}

#利用remove删除指定元素
a.remove(1)
a => {2,3}

利用推导式创建序列

列表推导

#语法： [表达式 for variable in 可迭代的对象]
a = [x for x in range(1,5)]
a => [1,2,3,4]

b = [x*2 for x in range(1,10) if (x*2)%3 == 0]
b => [6,12,18]

字典推导

#语法：{key_expression : value_expression for 表达式 in 可迭代的对象}
value = "abcdefgjklmdsfsfalksadjfk"
char_count ={c:value.count(c) for c in value}
char_count => {'a': 3, 'b': 1, 'c': 1, 'd': 3, 'e': 1, 'f': 4, 'g': 1, 'j': 2, 'k': 3, 'l': 2, 'm': 1, 's': 3}

集合推导

a = {x for x in range(1,100) if x%9==0}
a =>{99, 36, 72, 9, 45, 81, 18, 54, 90, 27, 63}

函数的定义和调用

• 语法
    def 函数名(参数1，参数2 or [参数列表]):
    '''文档字符串''' #注释用的
    函数体/若干语句
  

def max_num(a,b):
'''比较大小'''
	if int(a)>int(b):
		return a
	else:
		return b
a = 10
b = 11
c = max_num(a,b)
print(c) => 11

文件操作

打开文件 open()

打开方式	执行操作
‘r’	以只读方式打开文件(默认)
‘w’	以写入的方式打开文件，会覆盖已存在的文件
‘x’	如果文件已经存在，使用此模式打开引发异常
‘a’	以写入模式打开，如果文件存在，则在末尾追加写入
‘b’	以二进制模式打开文件
‘t’	以文本模式打开(默认)
‘+’	可读写模式(可添加到其他模式中使用)
‘U’	支持 通用换行符

文件对象方法

文件对象方法	执行操作
f.close	关闭文件
f.read(size=1)	从文件中读取size个字符，当未给定size或给定负值时，读取剩余的所有字符，然后作为字符串返回
f.readline()	以写入模式打开，如果文件存在，则在末尾追加写入
f.write(str)	将字符串str写入文件
f.writelines(seq)	向文件写入字符串序列seq,seq应该是一个返回字符串的可迭代对象
f.seek(offset,from)	在文件中移动文件指针，从from(0代表文件起始位置，1代表当前位置，2代表文件末尾),偏移offset个字节
f.tell()	返回当前在文件的位置