python---列表，元组，字符串

 

数据类型

 

计算机顾名思义就是可以做数学计算的机器，因此，计算机程序理所当然地可以处理各种数值。但是，计算机能处理的远不止数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。在Python中，能够直接处理的数据类型有以下几种

 

一 Number(数字)

 

1.1 数字类型的创建

a=10
b=a
b=666
 
print(a)#10
print(b)#666
View Code

 

 

 

 

注意这里与C的不同：

#include <stdio.h>
void main(void)
{
 
    int a = 1;
    int b = a;
    printf ("a:adr:%p,val:%d,b:adr:%p,val:%d\n",&a,a,&b,b);
    a = 3;
    printf ("a:adr:%p,val:%d,b:adr:%p,val:%d\n",&a,a,&b,b);
 
}
 
//打印结果：
topeet@ubuntu:~$ gcc test.c
topeet@ubuntu:~$ ./a.out
a:adr:0x7fff343a069c,val:1
b:adr:0x7fff343a0698,val:1
a:adr:0x7fff343a069c,val:3
b:adr:0x7fff343a0698,val:1
View Code

 

 

1.2 Number 类型转换

var1=3.14
var2=5
var3=int(var1)
var4=float(var2)
 
print(var3,var4)
View Code

 

二 字符串类型（string）

 

字符串是以单引号'或双引号"括起来的任意文本，比如'abc'，"123"等等。

 

请注意，''或""本身只是一种表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。如果'本身也是一个字符，那就可以用""括起来，比如"I'm OK"包含的字符是I，'，m，空格，O，K这6个字符。

 

2.1 创建字符串：

 

1
2
var1 = 'Hello World!'
var2 = "Python RAlvin"

 

对应操作：

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 1   * 重复输出字符串
print('hello'*2)
 
# 2 [] ,[:] 通过索引获取字符串中字符,这里和列表的切片操作是相同的,具体内容见列表
print('helloworld'[2:])
 
# 3 in  成员运算符 - 如果字符串中包含给定的字符返回 True
print('el' in 'hello')
 
# 4 %   格式字符串
print('alex is a good teacher')
print('%s is a good teacher'%'alex')
 
 
# 5 +   字符串拼接
a='123'
b='abc'
c='789'
d1=a+b+c
print(d1)
# +效率低,该用join
d2=''.join([a,b,c])
print(d2)

 

python的内置方法

 

 View Code

 

三 字节类型(bytes)

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# a=bytes('hello','utf8')
# a=bytes('中国','utf8')
 
 
a=bytes('中国','utf8')
b=bytes('hello','gbk')
#
print(a)        #b'\xe4\xb8\xad\xe5\x9b\xbd'
print(ord('h')) #其十进制 unicode 值为: 104
print(ord('中'))#其十进制 unicode 值为:20013
 
#  h   e  l   l   o
# 104 101 108 108 111   编码后结果:与ASCII表对应
 
 
#     中                国
#   \xd6\xd0         \xb9\xfa       gbk编码后的字节结果
#\xe4 \xb8 \xad   \xe5 \x9b \xbd    utf8编码后的字节结果
# 228 184 173      229 155  189        a[:]切片取
 
 
c=a.decode('utf8')
d=b.decode('gbk')
#b=a.decode('gbk') :很明显报错
 
print(c) #中国
print(d) #hello　

 

注意：对于 ASCII 字符串，因为无论哪种编码对应的结果都是一样的，所以可以直接使用 b'xxxx' 赋值创建 bytes 实例，但对于非 ASCII 编码的字符则不能通过这种方式创建 bytes 实例，需要指明编码方式。

 

1
2
3
4
5
6
b1=b'123'
print(type(b1))
# b2=b'中国' #报错
# 所以得这样:
b2=bytes('中国','utf8')
print(b2)#b'\xe4\xb8\xad\xe5\x9b\xbd'

 

四 布尔值

 

一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写）

 

1
2
3
4
print(True)
print(4>2)
print(bool([3,4]))
print(True+1)

 

与或非操作：

 

1
2
3
4
bool(1 and 0)
bool(1 and 1)
bool(1 or 0)
bool(not 0)

 

布尔值经常用在条件判断中:

 

1
2
3
4
5
age=18
if age>18:#bool(age>18)
    print('old')
else:
    print('young')

 

　　

 

五 List（列表）

 

      OK,现在我们知道了字符串和整型两个数据类型了，那需求来了，我想把某个班所有的名字存起来，怎么办？

 

有同学说，不是学变量存储了吗，我就用变量存储呗，呵呵，不嫌累吗，同学，如班里有一百个人，你就得创建一百个变量啊，消耗大，效率低。

 

又有同学说，我用个大字符串不可以吗，没问题，你的确存起来了，但是，你对这个数据的操作（增删改查）将变得非常艰难，不是吗，我想知道张三的位置，你怎么办？

 

 

 

在这种需求下，编程语言有了一个重要的数据类型－－－－列表（list）

 

 

 

什么是列表：

 

列表（list）是Python以及其他语言中最常用到的数据结构之一。Python使用使用中括号 [ ] 来解析列表。列表是可变的（mutable）——可以改变列表的内容。

 

 

 

对应操作：

 

1 查（［］）

 

1
2
3
4
5
6
7
8
9
10
names_class2=['张三','李四','王五','赵六']
 
# print(names_class2[2])
# print(names_class2[0:3])
# print(names_class2[0:7])
# print(names_class2[-1])
# print(names_class2[2:3])
# print(names_class2[0:3:1])
# print(names_class2[3:0:-1])
# print(names_class2[:])　

 

2 增（append，insert）

 

insert 方法用于将对象插入到列表中，而append方法则用于在列表末尾追加新的对象

 

1
2
3
names_class2.append('alex')
names_class2.insert(2,'alvin')
print(names_class2)

 

3 改（重新赋值）

 

1
2
3
4
5
names_class2=['张三','李四','王五','赵六']
 
names_class2[3]='赵七'
names_class2[0:2]=['wusir','alvin']
print(names_class2)

 

4 删（remove，del，pop）

 

1
2
3
4
names_class2.remove('alex')
del names_class2[0]
del names_class2
names_class2.pop()#注意,pop是有一个返回值的　

 

5 其他操作

 

5.1  count

 

       count 方法统计某个元素在列表中出现的次数：

 

1
2
3
4
5
6
7
>>> ['to', 'be', 'or', 'not', 'to', 'be'].count('to') 
2 
>>> x = [[1,2], 1, 1, [2, 1, [1, 2]]] 
>>> x.count(1) 
2 
>>> x.count([1,2]) 
1

 

5.2 extend

 

         extend 方法可以在列表的末尾一次性追加另一个序列中的多个值。

 

1
2
3
4
5
>>> a = [1, 2, 3] 
>>> b = [4, 5, 6] 
>>> a.extend(b) 
>>> a 
[1, 2, 3, 4, 5, 6] 

 

　　extend 方法修改了被扩展的列表，而原始的连接操作（+）则不然，它会返回一个全新的列表。

 

1
2
3
4
5
6
7
8
9
10
>>> a = [1, 2, 3] 
>>> b = [4, 5, 6] 
>>> a.extend(b) 
>>> a 
[1, 2, 3, 4, 5, 6] 
>>> 
>>> a + b 
[1, 2, 3, 4, 5, 6, 4, 5, 6] 
>>> a 
[1, 2, 3, 4, 5, 6] 

 

5.3  index

 

       index 方法用于从列表中找出某个值第一个匹配项的索引位置：　

 

1
names_class2.index('李四')

 

5.4  reverse

 

       reverse 方法将列表中的元素反向存放。

 

1
2
names_class2.reverse()
print(names_class2)

 

5.5  sort

 

       sort 方法用于在原位置对列表进行排序。

 

1
2
x = [4, 6, 2, 1, 7, 9]
x.sort()#x.sort(reverse=True)

 

5.6  深浅拷贝

 

现在，大家先不要理会什么是深浅拷贝，听我说，对于一个列表，我想复制一份怎么办呢？

 

肯定会有同学说，重新赋值呗：

 

1
2
names_class1=['张三','李四','王五','赵六']
names_class1_copy=['张三','李四','王五','赵六']

 

这是两块独立的内存空间

 

这也没问题，还是那句话，如果列表内容做够大，你真的可以要每一个元素都重新写一遍吗？当然不啦，所以列表里为我们内置了copy方法：

 

1
2
3
4
5
6
7
8
9
10
11
12
13
names_class1=['张三','李四','王五','赵六',[1,2,3]]
names_class1_copy=names_class1.copy()
 
names_class1[0]='zhangsan'
print(names_class1)
print(names_class1_copy)
 
############
names_class1[4][2]=5
print(names_class1)
print(names_class1_copy)
 
#问题来了,为什么names_class1_copy,从这一点我们可以断定,这两个变量并不是完全独立的,那他们的关系是什么呢?为什么有的改变,有的不改变呢?

 

这里就涉及到我们要讲的深浅拷贝了：

#不可变数据类型:数字,字符串,元组         可变类型:列表,字典
 
# l=[2,2,3]
# print(id(l))
# l[0]=5
# print(id(l))   # 当你对可变类型进行修改时,比如这个列表对象l,它的内存地址不会变化,注意是这个列表对象l,不是它里面的元素
#                # this is the most important
#
# s='alex'
# print(id(s))   #像字符串,列表,数字这些不可变数据类型,,是不能修改的,比如我想要一个'Alex'的字符串,只能重新创建一个'Alex'的对象,然后让指针只想这个新对象
#
# s[0]='e'       #报错
# print(id(s))
 
#重点:浅拷贝
a=[[1,2],3,4]
b=a[:]#b=a.copy()
 
print(a,b)
print(id(a),id(b))
print('*************')
print('a[0]:',id(a[0]),'b[0]:',id(b[0]))
print('a[0][0]:',id(a[0][0]),'b[0][0]:',id(b[0][0]))
print('a[0][1]:',id(a[0][1]),'b[0][1]:',id(b[0][1]))
print('a[1]:',id(a[1]),'b[1]:',id(b[1]))
print('a[2]:',id(a[2]),'b[2]:',id(b[2]))
 
 
print('___________________________________________')
b[0][0]=8
 
print(a,b)
print(id(a),id(b))
print('*************')
print('a[0]:',id(a[0]),'b[0]:',id(b[0]))
print('a[0][0]:',id(a[0][0]),'b[0][0]:',id(b[0][0]))
print('a[0][1]:',id(a[0][1]),'b[0][1]:',id(b[0][1]))
print('a[1]:',id(a[1]),'b[1]:',id(b[1]))
print('a[2]:',id(a[2]),'b[2]:',id(b[2]))<br><br><br>#outcome

# 4331943624 4331943752
# *************
# a[0]: 4331611144 b[0]: 4331611144
# a[0][0]: 4297375104 b[0][0]: 4297375104
# a[0][1]: 4297375136 b[0][1]: 4297375136
# a[1]: 4297375168 b[1]: 4297375168
# a[2]: 4297375200 b[2]: 4297375200
# ___________________________________________
# [[8, 2], 3, 4] [[8, 2], 3, 4]
# 4331943624 4331943752
# *************
# a[0]: 4331611144 b[0]: 4331611144
# a[0][0]: 4297375328 b[0][0]: 4297375328
# a[0][1]: 4297375136 b[0][1]: 4297375136
# a[1]: 4297375168 b[1]: 4297375168
# a[2]: 4297375200 b[2]: 4297375200
View Code

 

 

那么怎么解释这样的一个结果呢？

 

  

 

 再不懂，俺就没办法啦...

 

列表补充：

 

b,*c=[1,2,3,4,5]

 

六 tuple（元组）

 

元组被称为只读列表，即数据可以被查询，但不能被修改，所以，列表的切片操作同样适用于元组。

 

元组写在小括号(())里，元素之间用逗号隔开。

 

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

 

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

 

1
2
tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

 

作用：

 

1 对于一些数据我们不想被修改，可以使用元组；

 

2 另外，元组的意义还在于，元组可以在映射（和集合的成员）中当作键使用——而列表则不行；元组作为很多内建函数和方法的返回值存在。 

 

字典

# product_list=[
#     ('book',100),
#     ('Mac Pro',9000),
#     ('watch',500),
#     ('coffee',30),
#     ('Python',106),]
# 
# saving=input('input your saving:')
# shopping_car=[]
# 
# if saving.isdigit():
#     saving=int(saving)
#     while True:
#         for i,v in enumerate(product_list):
#             print(i,v)
#         user_choice=input('选择购买商品编号[退出:q]:')
# 
#         if user_choice.isdigit():
#             user_choice=int(user_choice)
#             if user_choice<len(product_list) and user_choice>=0:
#                 product_item=product_list[user_choice]
#                 if product_item[1]<saving:
#                     saving-=product_item[1]
#                     shopping_car.append(product_item)
#                     print('您当前的余额为%s'%saving)
#             else:
#                 print('编号错误')
#         elif user_choice=='q':
#             print('---------您已经购买如下商品-----------')
#             for i in shopping_car:
#                 print(i)
#             print('您的余额为%s'%saving)
#             break
# 
#         else:
#             print('invalid choice')
购物车

 

 

七 Dictionary（字典）

 

字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。

 

字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

 

创建字典：     

 

1
2
3
4
dic1={'name':'alex','age':36,'sex':'male'}
dic2=dict((('name','alex'),))
print(dic1)
print(dic2)

 

对应操作：

 

1 增

 

1
2
3
4
5
6
7
8
9
10
dic3={}
 
dic3['name']='alex'
dic3['age']=18
print(dic3)#{'name': 'alex', 'age': 18}
 
a=dic3.setdefault('name','yuan')
b=dic3.setdefault('ages',22)
print(a,b)
print(dic3)

 

2 查

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
dic3={'name': 'alex', 'age': 18}
 
# print(dic3['name'])
# print(dic3['names'])
#
# print(dic3.get('age',False))
# print(dic3.get('ages',False))
 
print(dic3.items())
print(dic3.keys())
print(dic3.values())
 
print('name' in dic3)# py2:  dic3.has_key('name')
print(list(dic3.values()))

 

3 改

 

1
2
3
4
5
6
dic3={'name': 'alex', 'age': 18}
 
dic3['name']='alvin'
dic4={'sex':'male','hobby':'girl','age':36}
dic3.update(dic4)
print(dic3)

 

4 删

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
dic4={'name': 'alex', 'age': 18,'class':1}
 
 
# dic4.clear()
# print(dic4)
del dic4['name']
print(dic4)
 
a=dic4.popitem()
print(a,dic4)
 
# print(dic4.pop('age'))
# print(dic4)
 
# del dic4
# print(dic4)

 

5 其他操作以及涉及到的方法

 

5.1 dict.fromkeys

 

1
2
3
4
5
6
7
8
9
10
d1=dict.fromkeys(['host1','host2','host3'],'Mac')
print(d1)
 
d1['host1']='xiaomi'
print(d1)
#######
d2=dict.fromkeys(['host1','host2','host3'],['Mac','huawei'])
print(d2)
d2['host1'][0]='xiaomi'
print(d2)

 

5.2  d.copy() 对字典 d 进行浅复制，返回一个和d有相同键值对的新字典

 

5.3  字典的嵌套

av_catalog = {
    "欧美":{
        "www.youporn.com": ["很多免费的,世界最大的","质量一般"],
        "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
        "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
        "x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"]
    },
    "日韩":{
        "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]
    },
    "大陆":{
        "1024":["全部免费,真好,好人一生平安","服务器在国外,慢"]
    }
}

av_catalog["大陆"]["1024"][1] += ",可以用爬虫爬下来"
print(av_catalog["大陆"]["1024"])
#ouput 
['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']
View Code

 

 

5.4 sorted(dict) : 返回一个有序的包含字典所有key的列表

 

1
2
dic={5:'555',2:'222',4:'444'}
print(sorted(dic))　

 

5.5 字典的遍历　　

 

1
2
3
4
5
6
7
8
9
dic5={'name': 'alex', 'age': 18}
 
for i in dic5:
    print(i,dic5[i])
 
for items in dic5.items():
    print(items)
for keys,values in dic5.items():
    print(keys,values)

 

　　

 

 还用我们上面的例子，存取这个班学生的信息，我们如果通过字典来完成，那：

 

1
2
3
4
dic={'zhangsan':{'age':23,'sex':'male'},
     '李四':{'age':33,'sex':'male'},
     'wangwu':{'age':27,'sex':'women'}  
     }

 

八 集合(set)

 

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

 

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

 

集合(set)：把不同的元素组成一起形成集合，是python基本的数据类型。

 

集合元素(set elements):组成集合的成员(不可重复)

 

1
2
3
4
5
6
7
li=[1,2,'a','b']
s =set(li)
print(s)    # {1, 2, 'a', 'b'}
 
li2=[1,2,1,'a','a']
s=set(li2)
print(s)  #{1, 2, 'a'}

 

集合对象是一组无序排列的可哈希的值：集合成员可以做字典的键　

 

1
2
3
li=[[1,2],'a','b']
s =set(li) #TypeError: unhashable type: 'list'
print(s)

 

集合分类：可变集合、不可变集合

 

可变集合(set)：可添加和删除元素，非可哈希的，不能用作字典的键，也不能做其他集合的元素

 

不可变集合(frozenset)：与上面恰恰相反

 

1
2
3
li=[1,'a','b']
s =set(li)
dic={s:'123'} #TypeError: unhashable type: 'set'

 

集合的相关操作　　

 

1、创建集合

 

     由于集合没有自己的语法格式，只能通过集合的工厂方法set()和frozenset()创建

 

1
2
3
4
5
6
s1 = set('alvin')
 
s2= frozenset('yuan')
 
print(s1,type(s1))  #{'l', 'v', 'i', 'a', 'n'} <class 'set'>
print(s2,type(s2))  #frozenset({'n', 'y', 'a', 'u'}) <class 'frozenset'>

 

2、访问集合

 

由于集合本身是无序的，所以不能为集合创建索引或切片操作，只能循环遍历或使用in、not in来访问或判断集合元素。

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
s1 = set('alvin')
print('a' in s1)
print('b' in s1)
#s1[1]  #TypeError: 'set' object does not support indexing
 
for i in s1:
    print(i)
#    
# True
# False
# v
# n
# l
# i
# a

 

3、更新集合

 

可使用以下内建方法来更新：

 

s.add()
s.update()
s.remove()

 

注意只有可变集合才能更新：

 

1
2
3
4
5
6
7
8
9
10
11
12
# s1 = frozenset('alvin')
# s1.add(0)  #AttributeError: 'frozenset' object has no attribute 'add'
 
s2=set('alvin')
s2.add('mm')
print(s2)  #{'mm', 'l', 'n', 'a', 'i', 'v'}
 
s2.update('HO')#添加多个元素
print(s2)  #{'mm', 'l', 'n', 'a', 'i', 'H', 'O', 'v'}
 
s2.remove('l')
print(s2)  #{'mm', 'n', 'a', 'i', 'H', 'O', 'v'}

 

del：删除集合本身　

 

四、集合类型操作符　

 

1   in ,not in
2   集合等价与不等价(==, !=)
3   子集、超集

 

1
2
3
4
s=set('alvinyuan')
s1=set('alvin')
print('v' in s)
print(s1<s)

 

      4   联合(|)

 

      联合(union)操作与集合的or操作其实等价的，联合符号有个等价的方法，union()。

 

1
2
3
4
5
s1=set('alvin')
s2=set('yuan')
s3=s1|s2
print(s3)  #{'a', 'l', 'i', 'n', 'y', 'v', 'u'}
print(s1.union(s2)) #{'a', 'l', 'i', 'n', 'y', 'v', 'u'}　

 

5、交集(&)

 

与集合and等价，交集符号的等价方法是intersection()

 

1
2
3
4
5
6
s1=set('alvin')
s2=set('yuan')
s3=s1&s2
print(s3)  #{'n', 'a'}
 
print(s1.intersection(s2)) #{'n', 'a'}

 

　　6、查集(-)
      等价方法是difference()

 

1
2
3
4
5
6
s1=set('alvin')
s2=set('yuan')
s3=s1-s2
print(s3)  #{'v', 'i', 'l'}
 
print(s1.difference(s2)) #{'v', 'i', 'l'}　

 

7、对称差集(^)

 

对称差分是集合的XOR(‘异或’)，取得的元素属于s1,s2但不同时属于s1和s2.其等价方法symmetric_difference()

 

1
2
3
4
5
6
s1=set('alvin')
s2=set('yuan')
s3=s1^s2
print(s3)  #{'l', 'v', 'y', 'u', 'i'}
 
print(s1.symmetric_difference(s2)) #{'l', 'v', 'y', 'u', 'i'}

 

应用

 

1
2
3
'''最简单的去重方式'''
lis = [1,2,3,4,1,2,3,4]
print list(set(lis))    #[1, 2, 3, 4]

 

 

1.列表

1.1定义列表：

names = ['Alex',"Tenglan",'Eric']

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

>>> names[0]

'Alex'
>>> names[2]
'Eric'
>>> names[-1]
'Eric'
>>> names[-2] #还可以倒着取
'Tenglan'
1.3切片:取多个元素
>>> names = ["Alex","Tenglan","Eric","Rain","Tom","Amy"]
>>> names[1:4]  #取下标1至下标4之间的数字，包括1，不包括4
['Tenglan', 'Eric', 'Rain']
>>> names[1:-1] #取下标1至-1的值，不包括-1
['Tenglan', 'Eric', 'Rain', 'Tom']
>>> names[0:3] 
['Alex', 'Tenglan', 'Eric']
>>> names[:3] #如果是从头开始取，0可以忽略，跟上句效果一样
['Alex', 'Tenglan', 'Eric']
>>> names[3:] #如果想取最后一个，必须不能写-1，只能这么写
['Rain', 'Tom', 'Amy'] 
>>> names[3:-1] #这样-1就不会被包含了
['Rain', 'Tom']
>>> names[0::2] #后面的2是代表，每隔一个元素，就取一个
['Alex', 'Eric', 'Tom'] 
>>> names[::2] #和上句效果一样
['Alex', 'Eric', 'Tom']
1.4追加
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy']
>>> names.append("我是新来的")
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的'
1.5插入
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
>>> names.insert(2,"强行从Eric前面插入")
>>> names
['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']

>>> names.insert(5,"从eric后面插入试试新姿势")
>>> names
['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']
1.6修改
>>> names
['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']
>>> names[2] = "该换人了"
>>> names
['Alex', 'Tenglan', '该换人了', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']
1.7删除
>>> del names[2] 
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']
>>> del names[4]
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
>>> 
>>> names.remove("Eric") #删除指定元素
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', '我是新来的']
>>> names.pop() #删除列表最后一个值 
'我是新来的'
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']
1.8扩展
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']
>>> b = [1,2,3]
>>> names.extend(b)
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]

1.9拷贝
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]

>>> name_copy = names.copy()
>>> name_copy
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]

1.10统计
>>> names
['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3]
>>> names.count("Amy")
2
1.11排序&翻转
>>> names
['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3]
>>> names.sort() #排序
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: int() < str()   #3.0里不同数据类型不能放在一起排序了，擦
>>> names[-3] = '1'
>>> names[-2] = '2'
>>> names[-1] = '3'
>>> names
['Alex', 'Amy', 'Amy', 'Tenglan', 'Tom', '1', '2', '3']
>>> names.sort()
>>> names
['1', '2', '3', 'Alex', 'Amy', 'Amy', 'Tenglan', 'Tom']

>>> names.reverse() #反转
>>> names
['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '3', '2', '1']
1.12获取下标
>>> names
['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '3', '2', '1']
>>> names.index("Amy")
2 #只返回找到的第一个下标
2.元组

1.语法

names = ("alex","jack","eric")    #它只有2个方法，一个是count,一个是index

2.应用

 

3.程序：购物车程序

 

   需求:

 

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

product_list = [['Iphone7',5800],
                ['Coffee',30],
                ['疙瘩汤',10],
                ['Python Book',99],
                ['Bike',199],
                ['ViVo X9',2499],

                ]

shopping_cart = {}

salary = int(input("input your salary:"))




while True:
    index = 0
    for product in product_list:
        print(index,product)
        index +=1
    choice = input(">>:").strip()
    if choice.isdigit(): #判断是否为数字
        choice = int(choice)
        if choice >= 0 and choice < len(product_list):#商品存在
            product = product_list[choice] #取到商品
            if product[1] <= salary:   #判断能否买的起
                #买的起
                if product[0] in shopping_cart: #之前购买过呀
                    shopping_cart[product[0]][1]  += 1 #[price, 数量],只需要把数量+1，加入购物车
                else:
                    shopping_cart[product[0]] = [product[1], 1]  #创建一条商品购买记录

                salary -= product[1] #扣钱
                print("Added product " + product[0] + " into shopping cart,\033[42;1myour current\033[0m balance " + str(salary) )
            else:
                print("买不起，穷逼! 产品价格是" + str(product[1])  + " 你还差" + str(product[1]-salary) + "钱")
        else:
            print("商品不存在!")
    elif choice == "q":
        print("-------已购买商品列表--------")
        #print(shopping_cart)
        id_counter = 1
        total_cost = 0 #初始化一个总花费的变量
        print("id    商品    数量      单价     总价")
        for key in shopping_cart:
            print("%s%10s%10s%10s%10s" %(id_counter,
                  key,
                  shopping_cart[key][1],
                  shopping_cart[key][0],
                  shopping_cart[key][1]*shopping_cart[key][0]))

            id_counter +=1
            total_cost += shopping_cart[key][1]*shopping_cart[key][0] #单个商品总价

        print("您的总花费为:",total_cost)
        print("您的余额为:",salary)
        print("----------end----------")
        break
    else:
        print("无此选项!")
3. 字符串操作

name.capitalize()  首字母大写
name.casefold()   大写全部变小写
name.center(50,"-")  输出 '---------------------Alex Li----------------------'
name.count('lex') 统计 lex出现次数
name.encode()  将字符串编码成bytes格式
name.endswith("Li")  判断字符串是否以 Li结尾
 "Alex\tLi".expandtabs(10) 输出'Alex      Li'， 将\t转换成多长的空格 
 name.find('A')  查找A,找到返回其索引， 找不到返回-1 

format :
    >>> msg = "my name is {}, and age is {}"
    >>> msg.format("alex",22)
    'my name is alex, and age is 22'
    >>> msg = "my name is {1}, and age is {0}"
    >>> msg.format("alex",22)
    'my name is 22, and age is alex'
    >>> msg = "my name is {name}, and age is {age}"
    >>> msg.format(age=22,name="ale")
    'my name is ale, and age is 22'
format_map
    >>> msg.format_map({'name':'alex','age':22})
    'my name is alex, and age is 22'


msg.index('a')  返回a所在字符串的索引
'9aA'.isalnum()   True

'9'.isdigit() 是否整数
name.isnumeric  
name.isprintable
name.isspace
name.istitle
name.isupper
 "|".join(['alex','jack','rain'])
'alex|jack|rain'


maketrans
    >>> intab = "aeiou"  #This is the string having actual characters. 
    >>> outtab = "12345" #This is the string having corresponding mapping character
    >>> trantab = str.maketrans(intab, outtab)
    >>> 
    >>> str = "this is string example....wow!!!"
    >>> str.translate(trantab)
    'th3s 3s str3ng 2x1mpl2....w4w!!!'

 msg.partition('is')   输出 ('my name ', 'is', ' {name}, and age is {age}') 

 >>> "alex li, chinese name is lijie".replace("li","LI",1)
     'alex LI, chinese name is lijie'

 msg.swapcase 大小写互换


 >>> msg.zfill(40)
'00000my name is {name}, and age is {age}'



>>> n4.ljust(40,"-")
'Hello 2orld-----------------------------'
>>> n4.rjust(40,"-")
'-----------------------------Hello 2orld'


>>> b="ddefdsdff_都都" 
>>> b.isidentifier() #检测一段字符串可否被当作标志符，即是否符合变量命名规则
True
如果还没学会，打开法宝

 

 

posted @ 2017-04-06 14:46  『心向阳﹡无所惧』  阅读(376)  评论(0)    收藏  举报