Python_python字符类型操作及文件操作

Posted 2020-10-18 zhufb

# 数组操作
stus = [‘xiaohong‘,‘xiaobai‘,‘xiaohei‘]  #中括号定义，下标从0开始，最后往前从-1开始
stus.append(‘xiaozhang‘)                   #List增加元素，默认增加在最后
stus.insert(1,‘xiaoming‘)                  #指定位置增加元素，下标不存在默认增加在最后
print(stus[1])                              #中括号下标获取对于List中对应下标元素
print(stus)                                 #不带下标获取所以List元素
stus.count(‘xiaohei‘)                      #查看元素的个数，不存在返回0
stus.index(‘xiaohei‘)                      #查看元素下标，多个返回第一个，不存在报错
stus[1] = ‘xiaohuang‘                      #修改对应元素，重新赋值
stus.pop(1)                                 #删除指定下标元素，默认删除最后，不存在报错，返回对应删除元素
stus.remove(‘xiaoming‘)                    #删除对应元素，多个则删除第一个，不存在报错，无返回
del stus[-1]                                #del关键字删除对应下标元素
stus.clear()                                #清空List
stus.reverse()                              #反转List元素顺序
stus.sort()                                 #List排序，默认升序排序
stus.sort(reverse=True)                     #指定reverse=True降序排序
stus.extend(all_num)                         #将all_num元素合并入stus中，all_num中元素不变

#多维数组
all_num = [1,2,3,[4,5,6,[7,8]]]             #多维数组使用多个中括号定义
print(all_num[3][3][1])                     #对应下标获取对应元素，下标从外向内取数

#数组循环和切片
names = [‘xiaohong‘,‘xiaobai‘,‘xiaohei‘,‘xiaoli‘,‘xiaozhang‘]
for name in names:                          #循环获取List中的元素
    print(name)
print(names[0:2])                            #切片取值，包前不包后（示例中获取下标为0、1两个元素）
print(names[:2])                             #切片取值，起始下标不填写默认为0开始
print(names[1:])                             #切片取值，结束下标不填写默认为最后结束
print(names[::2])                            #切片指定步长取值，默认步长为1
print(names[::-1])                           #切片指定步长取值，步长为正从左往右取值，负则从右往左取值

#字符串切片和循环取值
title = ‘niuniu zahuopu‘       #字符串存在下标，可以通过切片取值
print(title[:8])                 #一个空格对应一个下标
for t in title:
    print(t)                     #循环获取字符串对应值
for i,t in enumerate(title):    #enumerate获取对应下标和元素
    print(‘key:{i},value:{t}‘.format(i=i,t=t))
    
# 字典K-V形式，取值方便顺捷
d = {‘name‘: ‘xiaohei‘,
     ‘age‘: 18,
     ‘sex‘: ‘man‘}                   #字典使用大括号定义Key，Value
print(d[‘name‘])                     #通过Key取值，不存在则报错
print(d.get(‘name‘))                 #get方法取值，不存在则返回None
d.get(‘xx‘, ‘xiaohei‘)              #给方法取值，未获取到则返回default值
d[‘addr‘] = ‘shanghai‘             #增加字典，直接赋值Key,Value，字典无序
d.setdefault(‘money‘, 10000)        #增加字典Key，Value
d[‘addr‘] = ‘shengzhen‘            #修改字典值，存在则修改，不存在则新增
d.pop(‘money‘)                      #根据Key删除某个字典
d.popitem()                          #随机删除某个字典
del d[‘addr‘]                       #del关键字删除对应字典
# d.clear()                            #清空字典
print(d.keys(), d.values())          #keys方法和values方法获取字典所有Key或Value
if ‘xiaohei‘ in d:                 #判断Key是否在字典中
    print(‘name is exited‘)
for k in d:                         #循环获取字典的Key
    print(k)
for k, v in d.items():              #items方法循环获取字典的Key和Value
    print(‘Key:{key},Value:{value}‘.format(key=k, value=v))
res = list(d.items())               #强制转换数组
print(res)

# 字典嵌套，字典嵌套字典或List
stus = [{‘name‘: ‘xiaohei‘,
         ‘age‘: 18,
         ‘score‘: {
             ‘chinese‘: 80,
             ‘english‘: 75}},
        {‘name‘: ‘xiaobai‘,
         ‘age‘: 18,
         ‘score‘: {
             ‘chinese‘: 80,
             ‘english‘: 90}}
        ]
print(stus[0][‘score‘][‘english‘])     #根据从外到内，根据下标或Key取值
total_score = stus[0][‘score‘].values()
print(sum(total_score))
total_score1 = 0
for score in total_score:
    score = int(score)
    total_score1 = total_score1 + score
    print(total_score1)

#元组操作
a = (1,1,2,3,4,5,6,7,8)                       #小括号定义元组，不允许修改，其他与List相同
print(a.count(‘1‘))                           #获取元组中某个元素的个数
print(a.index(1))                             #获取元组中某个元素的下标，多个则返回第一个

#可变变量：list，字典
#不可变变量：元组，字符串
li = [1,1,2,3,4,5,6,7,8]
for i in li:                                #在循环操作时不要删除可变变量，删除元素会导致下标变化取值错误
   if i%2 !=0:
       li.remove(i)
print(li)
li2 = li                                   #浅拷贝，内存地址不变
li3 = li[:]                                #深拷贝
print(id(li2))                             #id方法获取对于内存地址
print(id(li3))

#字符串操作，不会改变原有字符串值
name = ‘besttest‘
new_name = name.strip()               #默认去除首尾的空格和换行符
new_name = name.strip(‘best‘)        #去除指定字符?
new_name = name.rsplit()             #去除右边的空格和换行符
new_name = name.lstrip()             #去除左边的空格和换行符
name_count = name.count(‘t‘)         #查找摸个字符在字符串中的个数
index = name.find(‘t‘)               #查找对应字符串中字符的下标，不存在返回-1，多个返回第一个
index = name.index(‘t‘)              #查找对应字符串中字符的下标，不存在报错
name.upper()                         #所有字符转换成大写
name.lower()                         #所有字符转换成小写
print(name.endswith(‘a‘))            #判断字符串以什么结束
print(name.startswith(‘a‘))          #判断字符串以什么开始
name.format()                        #字符串格式化
d ={‘name‘:‘xiaohei‘,‘age‘:18}
f = ‘我是{name}，今年{age}岁‘
print(f.format_map(d))               #将一个字典格式化
name.replace(‘best‘,‘better‘)      #字符串替换（‘old‘,‘new‘）
print(‘122‘.isdigit())              #判断是否全为数字
print(‘122‘.isalnum())              #判断字符串是否为数字或字母
print(‘122‘.isalpha())              #判断字符串是否为英文字母

#字符串分割
st = ‘a, b, c, d, e‘
st.split(‘,‘)                       #按照某个字符分割字符串返回list，默认安装空格分割
slit = [‘a‘,‘b‘,‘c‘,‘d‘]
res = ‘,‘.join(slit)               #将字符串、字典、list等（非int和布尔类型）以某个字符连接成一个字符串
print(res)

#非空即真
a = ‘  ‘                  #判断a是否为真，当a不为空则为真，即非空即真
if a:
    print(‘True‘)
else:
    print(‘false‘)

# 非零即真
num = 1                #判断num是否为零，当num不为零则为真，即非空即真
if num:
    print(‘True‘)
else:
    print(‘false‘)
    
#文件操作，打开文件之后必须关闭文件，不要在循环中打开文件
f = open(‘aa.txt‘,encoding=‘UTF-8‘)    #打开文件，指定编码格式
print(f.read())                         #读取文件内容
f.close()                               #关闭文件
f.write(‘xiaohei‘)                     #写文件，必须为字符串类型
f.write(‘xiaohei‘+‘\n‘)               #换行写文件

#文件打开模式
open(‘aa.txt‘,‘r‘,encoding=‘UTF-8‘)
              #‘r‘   只读模式，默认打开模式，文件不存在则报错
              #‘r+‘  读写模式，文件不存在报错
              #‘w‘    写模式，会清空文件内容
              #‘w+‘    写读模式，会清空文件内容
              #‘a‘      追加模式
              #‘a+‘     追加读写模式，文件指针在文件末尾，从末尾增加
f.seek(0)                            #将文件指针前移文件最开始，只针对读可用
print(f.readline())                  #按行读取，只读取一行内容
print(f.readlines())                 #读取文件所有内容，返回list，每一行作为一个元素
names = [‘xiaohei‘,‘xiaobai‘]
f.writelines(names)                  #将可循环的变量写入文件
f.truncate()                         #清空文件
f.tell()                             #查看当前文件指针位置

#高效出来文件方法，每次去用一行
for f in f:
    print(f)
for f in f:
    f = f.strip()                   #去除每行的换行符和空格
    stu_lst = f.split(‘,‘)         #根据逗号分割一行的内容为list
    print(stu_lst)