人生苦短，我学python-day3

之前学习的都是数字类型的数据，字符串也是简单了解一下输入与输出和判断。

然而要想实现高级的逻辑，仅靠这些数据类型远远不够，因此字符串、字典、元组、列表加入其中！来吧come!

先明确重中之重： 列表 和 元组

先附数据类型：

先了解一下序列：

序列：在python当中，序列就是一组按照顺序排列的值【数据集合】

在python中 存在3种内置的序列类型：
字符串、列表、元组

优点：可以支持 索引 和 切片 的操作，元组的较为特殊

特征：第一个正索引为0，指向的是左端(集合左端)，第一个索引为负数的时候，指向的是右端的0开始，然后-1、-2等

索引：索引就是每个数据相当于映射成一个 数字，方便我们找到这个数字就可以找到数据。这三种一般都是用 [ 索引号】来进行找

切片：切片是指截取字符串中的其中一段内容。 切片使用语法：[起始索引号：结束索引号：步长] ，起始和结束都是数据映射的 一个数字而已，切片截取的内容不包含结束下标对应的数据（range也是）， 步长指的是隔几个下标获取一个字符。

字符串

字符串用法大全

索引基础操作：

Test='python'
print(type(Test))
print('获取第一个字符%s'%Test[0])
print('获取第二个字符%s'%Test[1])

结果为：

<class 'str'>
获取第一个字符p
获取第二个字符y

切片基础操作：

strMsg='hello world'
print(strMsg) #输出完整的数据
print(strMsg[0])
print(strMsg[2:5]) #2-5下标之间的数据,步长=我们打印的数据长度
print(strMsg[2:]) #第三个字符到最后
print(strMsg[:3]) #1-3    strMsg[0:3]=strMsg[:3]
print(strMsg[::-1]) #倒叙输出  负号表示方向  从右边往左去遍历

结果为：

hello world
h
llo
llo world
hel
dlrow olleh

常见字符串用法：
用法：strmmsg = ‘字符串’
strmsg.函数

这些字符串常用函数返回值 可能是字符串、索引号、布尔类型等等
部分例子：
1.capitalize（）：首字母变大写

strMsg='hello world'
print(strMsg.capitalize())

结果为：

Hello world

2.strip()/lstrip/rstrip():去字符串的空格

strMsg='      hello world    '
print(strMsg)
print(strMsg.strip())
print(strMsg.rstrip())

结果为：

      hello world    
hello world
      hello world

3.find/ index()：查找 startswith（）/endweith（）:判断首尾字符串

dataStr='I love Python'
print(dataStr.find('o'))#查找的是第一个字符串的索引号
print(dataStr.find('M')) #find函数可以查找目标对象在序列对象中的为值,如果没找到就返回-1

print(dataStr.index('o'))#查找的是第一个字符串的索引号
# print(dataStr.index('W')) #检测字符串中是否包含子字符串 返回的是下标值
# index如果没有找到对象的数据 便会报异常，而find函数不会，找不到返回-1

print(dataStr.startswith('I'))  #判断开头
print(dataStr.endswith('n'))#判断结尾

结果为：

3
-1
3
True
False

4.lower（）/upper（）：转换大小写

dataStr='I love Python'
print(dataStr.lower()) #转换成小写
print(dataStr.upper())#转换成大写

结果为：

i love python
I LOVE PYTHON

列表

list:python当中非常重要的数据结构，是一种有序的数据集合

特点：
1：支持增删改查

2：列表中的数据是可以变化的【数据项可以变化，内存地址不会改变】

3:用[ ] 来表示列表类型，数据项之间用逗号来分割，注意：数据项可以是任何类型的数据 [1,2,3’kzkzkzkz’ ]

4：和字符串相似，支持索引和切片来进行操作，支持for循环的遍历 而且和字符串的用法基本一样

基础用法：

list = [] #空列表
print(type(list)) #标明是列表类型
print(list)
list = [1,2,3,'宝宝'] #数据用逗号隔开
print(len(list))
print(list)

结果为：

<class 'list'>
[]
4
[1, 2, 3, '宝宝']

len():对字符串是输出字符串长度。 对列表：输出列表的数据个数

列表用法大全

索引/切片基础操作：

listA=['aaa',777,12.23,'kz',True]
print(listA) #输出完整的列表
print(listA[0]) #输出第一个元素
print(listA[1:3]) #从第二个开始到第三个元素
print(listA[2:]) #从第三个元素开始到最后所有的元素
print(listA[::-1]) #负数从右像左开始输出
print(listA*3) #输出多次列表中的数据【复制】

结果为：

['aaa', 777, 12.23, 'kz', True]
aaa
[777, 12.23]
[12.23, 'kz', True]
[True, 'kz', 12.23, 777, 'aaa']
['aaa', 777, 12.23, 'kz', True, 'aaa', 777, 12.23, 'kz', True, 'aaa', 777, 12.23, 'kz', True]

常用列表用法：

举例1：添加append()/insert（） :

listA=['aaa',777,12.23,'kz',True]
print(listA) #输出完整的列表
listA.append(666)#列表添加数据
print(listA)
listA.append(['宝宝',222])#列表中嵌套列表
print(listA)

结果为：

['aaa', 777, 12.23, 'kz', True]
['aaa', 777, 12.23, 'kz', True, 666]
['aaa', 777, 12.23, 'kz', True, 666, ['宝宝', 222]]

list():

listA = [2,'kz',12.3]
listA.insert(1,'这是我刚插入的数据') #插入操作 需要指定一个位置插入
print(listA)

结果为：

[2, '这是我刚插入的数据', 'kz', 12.3]

举例2：修改列表某一项

listDate = list(range(1,6)) #强制转换为list对象
print(listDate)
listDate[0]=333.6 #修改列表的值
print(listDate)

结果为：

[1, 2, 3, 4, 5]
[333.6, 2, 3, 4, 5]

list()强制转换其他类型为列表。

举例3：删除 del / remove /pop
注意这三者的区别：

listDate = list(range(10,20)) #强制转换为list对象
print(listDate)
del listDate[0] #用索引的方式删除
print(listDate)
del listDate[1:3] #用切片的方式删除
print(listDate)
listDate.remove(15) #移除指定的元素  参数是具体的数据值
print(listDate)
listDate.pop(2) #删除索引号对应的数据
print(listDate)
print(listDate.index(18))  #返回的是一个索引下标

结果为：

[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
[11, 12, 13, 14, 15, 16, 17, 18, 19]
[11, 14, 15, 16, 17, 18, 19]
[11, 14, 16, 17, 18, 19]
[11, 14, 17, 18, 19]
3

元组

元组：是一种不可变的序列，在创建之后不能做任何的修改

1：不可变（即不能添加或者删除等操作），与列表不同点
2：用（ ）创建元组类型，数据项用逗号来分割
3：可以是任何的类型
4：当元组中只有一个元素时，要加上逗号，不然后解释器会当做其他类型来处理
5：同样可是支持索引和切片操作

基础用法：

tupleA=() #空元组
print(type(tupleA)) #类型
print(id(tupleA))#看数据地址
print(tupleA)
tupleA=('abcd',89,9.12,'kyros',[11,22,33])
print(tupleA)

结果为：

<class 'tuple'>
1450900275264
()
('abcd', 89, 9.12, 'kyros', [11, 22, 33])

元组用法大全

1.索引/切片查询：

tupleA = ('abcd',89,9.12,'kyros',[11,22,33])
for item in tupleA:   #遍历元组
    print(item,end=' ')
print()
print(tupleA[2:4])#打印索引号2-4
print(tupleA[::-1]) #倒打
print(tupleA[::-2]) #表示反转字符串 每隔一个打印一次
print(tupleA[::-3]) #表示反转字符串 每隔两个打印一次
print(tupleA[-2:-1:]) #倒着取下标，最右是0，-1开始到-2之间，但是-2是开区间，取不到
print(tupleA[-4:-2:]) #倒着取下标 为-2到-4区间的

结果为：

abcd 89 9.12 kyros [11, 22, 33] 
(9.12, 'kyros')
([11, 22, 33], 'kyros', 9.12, 89, 'abcd')
([11, 22, 33], 9.12, 'abcd')
([11, 22, 33], 89)
('kyros',)
(89, 9.12)

2.添加修改删除：元组不可以！！！

tupleA = ('abcd',89,9.12,'kyros',[11,22,33])
# tupleA[0]='PythonHello'  #错误的
tupleA[4][0]=285202  #修改元组4号列表的0号值
print(tupleA)
print(type(tupleA[4]))

结果为：

('abcd', 89, 9.12, 'kyros', [285202, 22, 33])
<class 'list'>

可见，添加操作是不可以的，仅仅可以对元组当中的列表进行修改
3.其他用法

tupleB=('1',) # 当元组中只有一个数据项的时候，必须要在第一个数据项后面加上 逗号
tupleC=(1,2,3,4,3,4,4,1)
tupleD=(range(10))#把range()转换成元组
print(tupleC.count(4)) #可以统计元素出现的次数
print(tupleD.count(4))

结果为：

3
1

记住.count（）大的用法就可以

字典

字典：也是python中重要的数据类型，字典是由 键值对 组成的集合，通常使用 键来访问数据，效率非常高，和list一样 支持对数据的添加、修改、删除

特点：

1：不是序列类型 没有下标的概念（即没有索引和切片），是一个无序的 键值集合，是内置的高级数据类型
2：用 { } 来表示字典对象，每个键值对用逗号分隔
3：键 必须是不可变的类型【元组、字符串】 值可以是任意的类型
4: 每个键必定是唯一的，如果存在重复的键，后者会覆盖前者

基础用法：

dicA = {} #空字典
#字典初始建立添加内容
dicA = {'addr':'西安','pos':'程序媛'}
#添加字典内容
print(type(dicA))
dicA['name'] = 'kyros' # name是键，kyros是键所指的的
dicA['age'] = 22
print(dicA)
print(len(dicA)) #获取字典个数

结果为：

<class 'dict'>
{'addr': '西安', 'pos': '程序媛', 'name': 'kyros', 'age': 22}
4

字典用法大全

1.索引/切片：查找/修改/删除

dicA = {'addr':'西安','pos':'程序媛','name':'kz'}
#查找
print(dicA['name']) #通过键获取对应的数据
#修改 添加
dicA['name'] = 'BOB'
dicA.update({'height':'180cm'})
print(dicA)
#删除 与列表元组类似
del dicA['addr']
print(dicA)
dicA.pop('pos')
print(dicA)

结果为：

kz
{'addr': '西安', 'pos': '程序媛', 'name': 'BOB', 'height': '180cm'}
{'pos': '程序媛', 'name': 'BOB', 'height': '180cm'}
{'name': 'BOB', 'height': '180cm'}

2.获取所有键/数据

dicA = {'addr':'西安','pos':'程序媛','name':'kz'}
#仅获取所有键
print(dicA.keys())
#仅获取所有数据
print(dicA.values())
#获取所有键和数据
print(dicA.items())
#依次遍历字典

结果为：

dict_keys(['addr', 'pos', 'name'])
dict_values(['西安', '程序媛', 'kz'])
dict_items([('addr', '西安'), ('pos', '程序媛'), ('name', 'kz')])

3.遍历字典

dicA = {'addr':'西安','pos':'程序媛','name':'kz'}
#依次遍历字典
for item in dicA.items():
    print(item)
for item in dicA.values():
    print(item)
#字典专用二个变量共同遍历
for key,value in dicA.items():
    # print('%s = %s'%(key,value))
    print('{} = {}'.format(key,value))

结果为：

('addr', '西安')
('pos', '程序媛')
('name', 'kz')
西安
程序媛
kz
addr = 西安
pos = 程序媛
name = kz

4.对字典排序（按ascal码）

dicA = {'height':'180cm',"addr":'西安','pos':'程序媛','name':'kz'}
print(dicA)
print(sorted(dicA.items(),key=lambda d:d[0]))#0是按key排序，若为1，则是根据value排序

结果为：

{'height': '180cm', 'addr': '西安', 'pos': '程序媛', 'name': 'kz'}
[('addr', '西安'), ('height', '180cm'), ('name', 'kz'), ('pos', '程序媛')]

字符串/列表/元组共有特点

加+

strA = 'KDAK'
strB = 'aed'
print(strA+strB)
listA = [1,22,3]
listB = [24,55,6]
print(listA+listB)

结果为：

KDAKaed
[1, 22, 3, 24, 55, 6]

元组类似，不写了

复制*

strA = 'KDAK'
print(strA*2)
listA = [1,22,3]
print(listA*2)

结果为：

KDAKKDAK
[1, 22, 3, 1, 22, 3]

元组同

判断元素是否存在 in

in 除了字符串、列表、元组。字典也可以（判断key）

in 很重要，记住哦！

strA = 'KDAK'
print('K' in strA)
listA = [1,22,3]
print(5 in listA)

结果为：

True
False

集合

集合是一种数据类型，无序且不重复，和字典类似，但只有key
不支持索引和切片
不重复这一点比较有用处，可以让我们强制转换一个序列为集合，就可以去除里面重复的数据，本文最后的案例就是对这个性质的一个应用

set1={1,2,3}
dic={1:2}
print(type(set1))
print(type(dic))

结果：

<class 'set'>
<class 'dict'>

集合常用方法

add():向集合添加数据
a.difference(b) :两个集合的差集，a中存在，b中不存在,生成一个新对象
a.intersection(b)两个集合的交集，a中存在，b中也存在的，生成一个新对象
a.union(b) 并集 包含a中的元素，也包含b中的元素，生成一个新对象
a.pop() 随机移除某个元素并且获取那个参数,集合pop没有参数,生成一个新对象,可用于随机数抽取
a.discard(元素) 移除某指定元素,生成一个新对象

案例：
指定一个列表，列表里含有唯一一个只出现过一次的数字。写程序找出这个“独一无二”的数字
两种方法：

# 指定一个列表，列表里含有唯一一个只出现过一次的数字。写程序找出这个“独一无二”的数字
#法1：for循环，用count计数
list=[12,3,3,4,5,4,5,6,5,6]
# print(list.count(3))
for i in list:
    if list.count(i)==1:
        print('独一无二的数为:{}'.format(i))
        break
    else:
        continue
    pass
#法2 转为set集合会自动去掉重复的元素
set1=set(list)
for i in set1:
    list.remove(i)#remove只会去指定i的一个
    pass
set2=set(list)
b=set1.difference(set2)
print('独一无二的数为：{}'.format(b))

结果;

独一无二的数为:12
独一无二的数为：{12}