python字符串、列表、字典基本操作-day2

　　通过上个博客的学习，相信大家已经对Python是什么东西应该有了相对应的了解，这里也包括Python的一些语法（比如Python在写for循环和if判断的时候都是会有缩进的）。这张博客大概会对Python数据类型做一个详细的解释。其中就包括字符串、元组、字典的一些用法。

本节内容

1. 列表、元组操作
2. 字符串操作
3. 字典操作
4. 集合操作
5. 文件操作
6. 字符编码与转码 

1. 列表、元组操作

列表是我们最以后最常用的数据类型之一，通过列表可以对数据实现最方便的存储、修改等操作

定义列表

names=["Leon","CHEN","WU”,"QIAO"]

通过下标访问列表中的元素，下标从0开始计数

>>> names[0]
'Leon'
>>> names[2]
'WU'
>>> names[-1]
'QIAO'
>>> names[1] #还可以倒着取
'CHEN'

切片:取多个元素

>>> names = ["Leon","CHEN","WU","QIAO"] #去所以0~2的值，这里记住，Python里面的去索引值时顾头不顾尾的
>>> names[0:2]
['Leon', 'CHEN']
>>> names[0:] #前面为0后面没有值，就是取所有
['Leon', 'CHEN', 'WU', 'QIAO']
>>> names[0::2] #后面的2是代表，每隔一个元素，就取一个
['Leon', 'WU']

追加

>>> names
['Leon', 'CHEN', 'WU', 'QIAO']
>>> names.append("LOVER")
>>> names
['Leon', 'CHEN', 'WU', 'QIAO', 'LOVER']

这里大家的了解一点就是追加是向列表中最后的位置添加一个值

插入

>>> names
['Leon', 'CHEN', 'WU', 'QIAO', 'LOVER']
>>> names.insert(2,"JACK") #在索引为2的地方插入“JACK”
>>> names
['Leon', 'CHEN', 'JACK', 'WU', 'QIAO', 'LOVER']
>>> names.insert(5,"MYLOVER") #在索引为5的点插入“MYLOVER”
>>> names
['Leon', 'CHEN', 'JACK', 'WU', 'QIAO', 'MYLOVER', 'LOVER']

>>> names
['Leon', 'CHEN', 'JACK', 'WU', 'QIAO', 'MYLOVER', 'LOVER']
>>> a = [1,2,3]
>>> names.extend(a) #在列表后面追加
>>> names
['Leon', 'CHEN', 'JACK', 'WU', 'QIAO', 'MYLOVER', 'LOVER', 1, 2, 3]
>>> name_copy = names.copy() #将names 复制一个name_copy
>>> name_copy
['Leon', 'CHEN', 'JACK', 'WU', 'QIAO', 'MYLOVER', 'LOVER', 1, 2, 3]
>>> names.count("CHEN") #计算出“CHEN”出现的次数
1
>>> names
['Leon', 'CHEN', 'JACK', 'WU', 'QIAO', 'MYLOVER', 'LOVER', 1, 2, 3]
>>> names.sort() “排序，按照 ASCII码正向排序
Traceback (most recent call last): #在Python3.X中字符串不能和数字放在一起
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: int() < str()
>>> names[-1] = "3"
>>> names[-2] = "2"
>>> names[-3] = "1"
>>> names
['CHEN', 'JACK', 'LOVER', 'Leon', 'MYLOVER', 'QIAO', 'WU', '1', '2', '3']
>>> names.sort()
>>> names
['1', '2', '3', 'CHEN', 'JACK', 'LOVER', 'Leon', 'MYLOVER', 'QIAO', 'WU']
>>> names.reverse() #反向排序
>>> names
['WU', 'QIAO', 'MYLOVER', 'Leon', 'LOVER', 'JACK', 'CHEN', '3', '2', '1']
>>> names.index("Leon")
3

这里大家需要知道一点copy方法的用处可不止这些，后面会介绍到

这里我们简单介绍下元祖

names = ("alex","jack","eric")
names.index()
names.count() 
#元组只有两种方法，这里就不试了

ps：三元运算

>>> a = 3
>>> b = 5
>>> c = a + b if a > b else a - b #if条件成立执行左边，否则执行右边
>>> c
-2

2. 字符串相关操作

name = 'wuzhihu	liuyao'
print(name.capitalize()) # 首字母变大写
print(name.casefold())  #全部变小写

print(name.center(9,'0')) #字符串长度不够的地方用指定的单个字符代替，先右后左
print(name.count('u')) #统计字符在字符串中出现的次数
print(name.encode()) #编码转换
print(name.endswith('h')) #判断字符串已什么结束，返回布尔值
print(name.expandtabs(5)) #如果字符串中有	建，则把	的值设置为50
print(name.find('u')) #在字符串中找到匹配的字符并返回下标
msg = 'ni hao {name},我今年{age}'
print(msg.format(age=22,name=name)) #另一种格式化输出，可以不考虑顺序，还可以直接定义变量
# print(name.format_map())
print(name.index('wu')) #字符索引
m = 'A'
print(num.isalnum())  #判断字符串是不是全部为阿拉伯数字和字母
print(num.isalpha())  #判断是否只包含阿拉伯字母
print(num.isdecimal()) #判断字符串是否只包含十进制数字
print(num.isdigit()) #判断字符串是否为数字，汉字数字为假
print(num.isidentifier()) #是不是一个合法的变量名
print(name.islower())  #判断是否是小写
print(num.isnumeric())  #判断是否为数字，可判断汉字
print(num.isprintable()) #可否打印
print(num.isspace()) #判断是否是空格，空不算，空为False
print(num.istitle())  #判断是否为标题
print(num.isupper()) #判断是否全部为大写
print(num.join('sdf')) #后面的字符串或列表用前面的字符串分割,只能操作一元列表
print(num.ljust(2,'a')) #从左边数，字符串长度不够用指定的单个字符填充
print(num.rjust(2,'a')) #从右边数，字符串长度不够用指定的单个字符填充
print(num.lower()) #将大写变为小写
print(num.lstrip()) #去除左边空白
print(num.rstrip()) #去除右边空白
print(num.rsplit()) #去除右边空白



from_str = "!@#$%^"
to_str = "abhziq"
trans_table = str.maketrans(to_str,from_str)
print("wuzhihu".translate(trans_table))

print('wuzhihu'.partition('u')) #按指定字符分割
print('wuzhihu'.replace('u','bbbbbbbbbbbbbb',1))  #替换字符 ,默认替换全部
print('wuzhihu'.split('z'))  #已指定字符切成列表

相信看过的人都应该发现了端倪，上面的变量对应的一些值为啥都是别人的名字呢，没错，这个并不是我的笔记，而是我同事吴志虎的，况且我做的笔记都这么详细，哪是他这种玩具笔记可以相提并论呢。0.0

3.字典的相关操作

字典一种key - value 的数据类型，使用就像我们上学用的字典，通过笔划、字母来查对应页的详细内容

语法:

info = {
    'name1': "LEON",
    'name2': "CHEN",
    'name3': "WU",
}

字典的特性：

• dict是无序的
• key必须是唯一的,so 天生去重

增加、删除、修改、查找

msg = {
    "name1":"Leon",
    "name2":"jack",
    "name3":"rose",
    "name4":"blue"
} #创建一个字典

>>> msg
{'name3': 'rose', 'name2': 'jack', 'name4': 'blue', 'name1': 'Leon'}
>>> msg["name5"] = "CHEN" #增加
>>> msg
{'name5': 'CHEN', 'name3': 'rose', 'name2': 'jack', 'name4': 'blue', 'name1': '
eon'}
>>> msg.pop("name4") #删除方式一
'blue'
>>> msg
{'name5': 'CHEN', 'name3': 'rose', 'name2': 'jack', 'name1': 'Leon'}
>>> del msg["name2"] #删除方式二
>>> msg
{'name5': 'CHEN', 'name3': 'rose', 'name1': 'Leon'}
>>> msg.popitem() #随机删除
('name5', 'CHEN')
>>> msg
{'name3': 'rose', 'name1': 'Leon'}
>>> "name3" in msg #查看key是否在字典中是返回true，否则FALSE
True
>>> msg.get("name3") #获取key对应的value
'rose'
>>> msg["name3"] #获取key 对应的value（方式二）
'rose'
>>> msg["name3"] = "CHEN" #修改key对应的value值
>>> msg
>>>{'name3': 'CHEN', 'name1': 'Leon'}

字典的多层嵌套

msg = {
    "中国":{
        "北京":"海淀",
        "上海":"徐家汇",
    },
    "美国":{
        "纽约":["皇后区","布鲁克林"],
        "洛杉矶":"好莱坞",
    }
}

ps:知识点补充

>>> for i,v in enumerate(range(3,10)):
...     print(i,v)
...
0 3
1 4
2 5
3 6
4 7
5 8
6 9

#通过上面的代码我们发现通过enumerate循环的值中分为两个部分i,v其实第一列是索引对应的是i，第二部分对应的是3-10索引的值

通过上面的博文我们得知了字典的一些基本用法，下面我们需要做一个补充

#values
>>> info.values()
dict_values(['LongZe Luola', 'XiaoZe Maliya'])

#keys
>>> info.keys()
dict_keys(['stu1102', 'stu1103'])


#setdefault
>>> info.setdefault("stu1106","Leon")
'Leon'
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Leon'}
>>> info.setdefault("stu1102","龙泽萝拉")
'LongZe Luola'
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Leon'}


#update 
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Leon'}
>>> b = {1:2,3:4, "stu1102":"龙泽萝拉"}
>>> info.update(b)
>>> info
{'stu1102': '龙泽萝拉', 1: 2, 3: 4, 'stu1103': 'XiaoZe Maliya', 'stu1106': 'Leon'}

#items
info.items()
dict_items([('stu1102', '龙泽萝拉'), (1, 2), (3, 4), ('stu1103', 'XiaoZe Maliya'), ('stu1106', 'Leon')])


#通过一个列表生成默认dict,有个没办法解释的坑，少用吧这个
>>> dict.fromkeys([1,2,3],'testd')
{1: 'testd', 2: 'testd', 3: 'testd'}

　　字典的循环：

#方法1
for key in info:
    print(key,info[key])

#方法2
for k,v in info.items(): #会先把dict转成list,数据里大时莫用
    print(k,v)

　　话说光看不做假把式，下面有一个联系，博友们也可以看一看

　　

程序：购物车程序

需求:

1. 启动程序后，让用户输入工资，然后打印商品列表
2. 允许用户根据商品编号购买商品
3. 用户选择商品后，检测余额是否够，够就直接扣款，不够就提醒 
4. 可随时退出，退出时，打印已购买商品和余额

procu_list = [
    ["iphone7",6500],["mackbook",12500],
    ["pen",2],["luleisi",55]
]
shopcart = []

money = int(input("you're money>>"))

while True:
    for i,x in enumerate(procu_list):
        print("%s	%s	%s"%(i,x[0],x[1]))
    choose = input(">>>").strip()
    if choose.isdigit():
        choose = int(choose)
        if choose < len(procu_list) and choose >= 0:
            product_list = procu_list[choose]
            if money >= product_list[1]:
                money -= product_list[1]
                shopcart.append(product_list)
                print("你购买的是%s花了%s你还剩%s赶紧提好裤子"%(product_list[0],product_list[1],money))
            else:
                lost = product_list[1] - money
                print("你还差%s赶紧把你的老板杀了，你就有钱了..."%(lost))
                continue

        else:
            print("请输入正确的序列")

    elif choose == "exit":
        print(money,shopcart)
        print("alrealding exit...")
        break

4.集合的相关操作

集合是一个无序的，不重复的数据组合，它的主要作用如下：

• 去重，把一个列表变成集合，就自动去重了
• 关系测试，测试两组数据之前的交集、差集、并集等关系

常用操作

s = set([3,5,9,10])      #创建一个数值集合  
  
t = set("Hello")         #创建一个唯一字符的集合  


a = t | s          # t 和 s的并集  
  
b = t & s          # t 和 s的交集  
  
c = t – s          # 求差集（项在t中，但不在s中）  
  
d = t ^ s          # 对称差集（项在t或s中，但不会同时出现在二者中）  
  
   
  
基本操作：  
  
t.add('x')            # 添加一项  
  
s.update([10,37,42])  # 在s中添加多项  
  
   
  
使用remove()可以删除一项：  
  
t.remove('H')  
  
  
len(s)  
set 的长度  
  
x in s  
测试 x 是否是 s 的成员  
  
x not in s  
测试 x 是否不是 s 的成员  
  
s.issubset(t)  
s <= t  
测试是否 s 中的每一个元素都在 t 中  
  
s.issuperset(t)  
s >= t  
测试是否 t 中的每一个元素都在 s 中  
  
s.union(t)  
s | t  
返回一个新的 set 包含 s 和 t 中的每一个元素  
  
s.intersection(t)  
s & t  
返回一个新的 set 包含 s 和 t 中的公共元素  
  
s.difference(t)  
s - t  
返回一个新的 set 包含 s 中有但是 t 中没有的元素  
  
s.symmetric_difference(t)  
s ^ t  
返回一个新的 set 包含 s 和 t 中不重复的元素  
  
s.copy()  
返回 set “s”的一个浅复制  

5.文本的相关操作

Flightless Bird  American Mouth - 暮光之城
I was a quick wet boy
Diving too deep for coins
All of your street light eyes
Wide on my plastic toys
And when the cops closed the fair
I cut my long baby hair
Stole me a dog-eared map
Called for you everywhere
Have I found you
Flightless bird jealous weeping
Or lost you
American mouth
Big pill looming
Now I'm a fat house cat
Nursing my sore blunt tongue
Watching the warm poison rats
Curl through the wide fence cracks
Pissing on magazine photos
Those fishing lures thrown in the cold and clean
Blood of Christ mountain stream
Have I found you
Flightless bird grounded bleeding
And or lost you
American mouth
Big pill stuck going down
Flightless Bird  American Mouth - 暮光之城

基本操作：

　　文件操作的基本顺序

• 打开文件
• 别写文件
• 关闭文件　

　　文件的三种打开方式：以读的模式打开（r），以写模式打开（w），以追加的模式打开（a）

　　ps：这里我们得注意一下，文件以读的方式打开就不能写，以写的模式打开就不能读。

　　实例一：

　　

f = open("filename","r",encoding="utf-8") #filename是文件名
date = f.read()
date = date.replace("oldfile","newfile") #oldfile是需要替换的地方，newfile是替换后的
f.close()

f = open("filename","w",encoding="utf-8")
f.write(date)
f.close()

另一种读取文件的方式：

　　

import os

f = open("filename","r",encoding="utf-8")
f_new = open(filename","w","encoding="utf-8")

for line in f:
    #print(line) #这张就可以直接读取文件所有的信息，第二行语句是为了后面替换使用的，于读取问加你无关
    if "oldfile" in f:
        line = line.replace("oldfile","newfile")
    f_new.write(line)

f.close()
f_new.close()

os.remove("filename")
os.rename("filename","new_filename")

6.字符编码的问题

因为我个人对这方面也不是特别清楚，所以就偷了懒，直接把别人的讲字符编码的博客地址给复制了过来^.^

博客地址：http://www.cnblogs.com/yuanchenqi/articles/5956943.html

这章博客可能做得有点粗糙，不过没有关系，如果有真正想学Python的朋友可以联系我

邮箱地址：yanweijian_tt@163.com