学习笔记(二)[语法进阶]

作者:加菲猫 2018-09-07 199 0

深浅拷贝

引用

list_1 = [1,2,3]
list_2 = list_1

list_1 修改其中元素时,list_2 也被影响

浅拷贝

list_1 = [1,2,3,['a','b','c']]
list_2 = list1[:]

只拷贝了最外层元素,修改 list_1 中的 1 时,list_2 不受影响,修改 list_1 中的 a 时,list_2 受影响

深拷贝

import copy
list_1 = [1,2,3,['a','b','c']]
list_2 = copy.deepcopy(list_1)

如何修改 list_1 中的元素,list_2 都不受影响

字典、集合

字典

  • 字典中的数据在内存里是无序的(不能使用索引和切片)

  • key 值会进行 hash 运算(所以 key 不能使用可变数据类型),生成哈希表(相当于目录),所以访问效率高

  • 创建

mydict = {1:'a',2:'b'}
mydict = dict(([1,'a'],[2,'b']))

# 批量创建 key,无法单独分配 value
mydict = dict.fromkeys([1,2,3],'a')
mydict = dict.fromkeys('abc',1)
  • 访问

mydict.keys()
mydict.values()

# 判断 key 是否存在,再取 value
if 1 in mydict
    mydict[1]

# 循环输出字典中的 key 和 value
for key in mydict:
    print(key,':',mydict[key])
  • 删除

del mydict[1]

# 用一个变量保存删除的 value
var = mydict.pop(1)

# 清空
mydict.clear()

集合

  • 可变集合 → set,不可变集合 → frozenset,不支持索引访问

  • 元素值会进行 hash 运算(所以元素的值不能是可变数据),且元素不能重复

  • 创建

# 可变
myset = {1,2,3}
myset = set([1,2,3])

# 不可变
myset = frozenset([1,2,3])
  • 访问

for var in myset:
    print(var)
  • 更新

# 直接添加一个元组
myset.add(('a','b','c'))

# 把元组拆成多个元素
myset.update(('a','b','c'))
  • 删除

myset.remove(1)
myset.discard(1)
var = myset.pop(1)
myset.clear()
  • 关系

myset1 = {1,2,3}
myset2 = {1,2,3,'a'}

# 判断是否为子集
# True
myset1 < myset2
# False
myset1.add('b')
myset1 < myset2

myset1 = {1,2,3,'a'}
myset2 = {1,2,3,'b'}

# 交集:{1,2,3}
myset1 & myset2

# 并集:{1,2,3,'a','b'}
myset1 | myset2

# 补集:{'a'}
myset1 - myset2

# 对称差分:{'a','b'}
myset1 ^ myset2

内建函数

字符串

  • 大小写转换

string.lower() 字母转换成小写
string.upper() 字母转换成大写
string.swapcase() 字母大写转换成小写,小写转换成大写
string.title() 首字母转化成大写,其它字母转换成小写,多段都改
string.capitalize() 首字母转化成大写,其它字母转换成小写,只改第一段
  • 搜索

string.find(target,start,end) 在 string 的 start 到 end 中,查找 target 的位置,如果没有返回 -1
string.index(target,start,end) 在 string 的 start 到 end 中,查找 target 的位置,如果没有 → 报错
string.count(target) 统计 target 在 string 中出现的次数
string.startswith(target) 判断 string 是否以 target 开始
string.endswith(target) 判断 string 是否以 target 结尾
  • 替换

string.replace(str1,str2,[num=string.count(str1)]) 将 str1 替换为 str2,num 为替换次数,默认为 str1 出现的次数
string.strip(chr) 在 string 的开头和结尾删除 chr
string.lstrip() / string.rstrip() 删除 string 开头 / 末尾的空白字符(空格、\n、\t)
  • 分割、组合

string.split(chr,num=string.count(str)) 以 chr 为分割符分割 string,结果保存在列表中,如果指定 num,则只分割 num 次
chr.join(str.[list,tuple]) 以 chr 为连接符,拼接字符串
  • 判断

string.isdigit() 是否只包含数字
string.islower() 字母是否全为小写
string.isupper() 字母是否全为大写
string.isspace() 是否只包含空白字符
  • 列表

list.append(obj) 在列表尾部追加元素
list.count(obj) 返回一个对象出现的次数
list.extend(seq) 把序列 seq 中的内容加入到列表中
list.insert(index,obj) 在 index 位置插入 obj,原位置内容后移
list.pop(index) 删除并返回对象,默认是最后一个
list.reverse() 反转列表
  • 元组

tuple.index(obj,start=0,end=len(string)) 检查 obj 是否包含在 tuple 中
tuple.count(obj) 返回一个对象出现的次数

系统

enumerate(iter) 传入一个可迭代的参数,返回 enumerate 对象,也是一个迭代器,是 iter 中每个元素的 index 和 item 值
len(seq) 返回 seq 的长度
max(iter,key=None) / min(iter,key=None) 取最大 / 小值,key 参数为比较规则,如 key = lambda x:x[1],说明要比较 [1] 位置的值
reversed(seq) 传入一个序列,返回逆序访问的迭代器
sorted(iter,cmp=None,key=None) 传入一个可迭代对象,返回一个有序列表,可传入排序方式
sum(seq,init=0) 返回列表和 init 的总和
zip(it0,it1,…itN) 对应索引上的值组合成一个新元素,直到最短的参数被用完,返回一个列表
map(func,seq) 第一个参数可以是一个函数对象,第二个参数是一个序列,函数依次作用在序列的每个元素上
reduce

reduce 把一个函数作用在一个序列上,这个函数必须接收两个参数,函数的结果会与下一个元素做累积计算

from functools import reduce
def func(x,y):
    return x*y
mylist = [1,2,3]    
reduce(func,mylist)

推导式

列表

mylist = [1,2,3,4,5]
# [1,4,16,25]
new_list = [var*var for var in mylist if var != 3]

# 生成器
new_list = (var*var for var in mylist if var != 3)
new_list.__next__()

字典

mylist = [1,2,3]
# {2:'a',3:'a'}
mydict = {var:'a' for var in mylist if var > 1}

集合

mylist = [1,2,3]
# {2,3,4}
myset = {var+1 for var in mylist}

文件操作

打开文件

# file:文件路径 + 名称,mode:操作类型(r:读、w:写、a:追加,带加号表示读写)
open(file,mode='r')

操作文件

  • 读(不传参数最多 200 M)

# num:要读取的字节数
mystr = myfile.read(num)
修改指针的位置,offset:偏移量,whence:从何处偏移(0:文件开头、1:当前位置、2:文件末尾)
mystr = myfile.seek(offset,whence)

# 读一行
mystr = myfile.readline()

# 读多行
mylist = myfile.readlines()

# for 按行读
mylist = []
for var in myfile:
    mylist.append(var)
# 写入,会覆盖上一次写的内容
myfile = open('1.txt','w')
myfile.write('abc\n')

# 追加
myfile = open('1.txt','a')
myfile.write('abc')

# 把内存中对文件的修改放到磁盘上
myfile.flush()

# 关闭文件
myfile.close()

# 备份文件
myfile1 = open('1.txt','r')
myfile2 = open('2.txt','a')

mylist = myfile1.readlines()
myfile2.writelines(mylist)

myfile1.close()
myfile2.close()
  • 文件加密

# 读,加密
import random
secretlist = ['!','@','#','$','%','^','&','*','=','<','~']
info_file = open('info.txt','r')
mylist = []
for var in info_file.read():
    index = random.randint(0,9)
    var = var + secretlist[index]
    mylist.append(var)
info_file.close()
# 写
info_file = open('info.txt','w')
new_str = ''.join(mylist)
info_file.write(new_str)
info_file.close()
  • 注册

account_file = open('register.txt','a+')
while True:
    has_account = False
    account = input('请输入账号:')
    # 移动读写指针到文件开头
    account_file.seek(0,0)
    for var in account_file:
        file_account = var.split(':')[0]
        if account == file_account:
            print('账号已被注册!')
            has_account = True
            break
    if has_account:
        continue
    # 接收密码,保存
    password = input('请输入密码:')
    new_account = account + ':' + password + '\n'
    account_file.write(new_account)
    account_file.close()
    break
  • 登录

account_file = open('account_info.txt','r')
while True:
    has_login = False
    account = input('请输入账号:')
    account_file.seek(0,0)
    for var in account_file:
        if has_login:
            break
        file_account = var.split(':')[0]
        if account == file_account:
            index = 3
            while index > 0:
                password = input('请输入密码:')
                file_password = var.split(':')[1].strip()
                if password == file_password:
                    print('登录成功!')
                    has_login = True
                    break
                else:
                    index -= 1
                    print('密码错误!你还有%d次机会' % index)
    if has_login:
        account_file.close()
        break
    print('请重新登录!')

发表评论