-
引入： 计算机是可以做数学计算的机器，因此，计算机程序理所当然地可以处理各种数值。但是，计算机能处理的远不止数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。在Python中，能够直接处理的数据类型有：数字、字符串、列表、元组、字典等。
-
关于序列： 在python当中 序列就是一组按照顺序排列的值【数据集合】
在python中 存在三种内置的序列类型：字符串、列表、元组
优点：可以支持索引和切片的操作
特征：第一个正索引为0，指向的是左端，第一个索引为负数的时候，指向的是右端
切片：【高级特性】可以根据下表来获取序列对象的任意[部分]数据
语法结构：[start : end : step] step默认1
Python-高级数据类型
1、字符串操作
1.1、 字符串常用方法
str='python'
print(str) #输出字符串str
print(type(str)) #type 查看数据类型
print(str[0]) #输出字符串str的第一个元素，即下标为0的元素
#遍历输出字符串
str1='I love Python'
for ietm in str1:
print(ietm,end='') #通过end=''控制输出不换行
pass
1.2、字符串常用函数
- 1.capitalize() 首字母变大写
- 2.endswith/startswith()是否 x结束/开始
- 3.find()检测x是否在字符串中
- 4.lower/upper 大小写转换
- 5.strip() 去除字符串中两边的空格 lstrip()/rstrip() 去除左边/右边空格
#字符串常用函数
name='joson'
print(name.capitalize()) #首字母大写
str=' I love Python '
print(str.startswith('i')) #是否以i开头，返回布尔值
print(str.find('o')) #查找第一次‘o' 出现的位置，从下标0 开始
print(str.find('M')) #查找第一次‘o' 出现的位置，从下标0 开始 ,若未找到返回-1
print(str.lower()) # 将字符串转化为小写
print(str.upper()) # 将字符串转化为小写
print(str.strip()) #去掉两边空格
print(str.lstrip()) #去掉左边空格
# 复制字符串
a='tom'
print('a的内存地址%d'%id(a)) #id函数 可以查看一个对象的内存地址
b=a #在此只是把a对象的内存地址赋给了b
print('b的内存地址%d'%id(b))
- 结果如下：
1.3、关于切片
- 切片是指截取字符串中的其中一段内容。 切片使用语法：[起始下标：结束下标：步长] 切片截取的内容不包含结束下标对应的数据，步长指的是隔几个下标获取一个字符。（下标会越界，切片不会）
#关于切片，实际上就是根据要求截取对应字符串 [start:end:step]
str='I love Python'
print(str[0:5]) #截取第1个到第6个字符，即从下标0开始到下标5，包括第一个，不包括第6个
print(str[0:5:2]) # 以步长为2从下标0开始截取到下标5结束，即截取第1,3,5个字符
#若起始值，结束值默认第一或者最后，可以省略
print(str[:])
print(str[0:5]) # str[0:5]=str[:5]
#倒叙输出
print(str[::-1])
- 结果如下：
1.4、与其他类型综合操作
# 共有方法 + * in
str1='今天心情真好'
str2='我想学习Python'
print(str1+str2) #通过’+‘ 将两个字符串合并
print(3*str1) #通过数字’*‘字符串，即将该字符串重复输出
print('我' in str1) #通过'in' 来查询对应的元素是否在该字符串中 返回布尔值
- 结果如下：
2、列表及常用方法
2.1、关于列表
列表list:python当中非常重要的数据结构，是一种有序的数据集合
特点：
1：支持增删改查
2：列表中的数据是可以变化的【数据项可以变化，内存地址不会改变】
3:用[] 来表示列表类型，数据项之间用逗号来分割，注意：数据项可以是任何类型的数据
4：支持索引和切片来进行操作
# 列表
li1=[] #空列表
print(li1)
print(type(li1)) #查看类型
li2=[1,2,3,'你好']
print(li2)
print(len(li2)) #len函数可以获取到列表对象中的数据个数
str='我喜欢python'
print(len(str))
2.2、列表常用函数、方法
- 函数 是封装了一些独立的功能，可以直接调用，能将一些数据（参数）传递进去进行处理，然后返回一些数据（返回值），也可以没有返回值。可以直接在模块中进行定义使用
- 常用函数:
cmp(list1, list2) 比较两个列表的元素 python3 已经无此函数
len(list) 列表元素个数
max()，min() 回列表元素最大值、最小值
- 方法 方法和函数类似，同样封装了独立的功能，但是方法是只能依靠类或者对象来调用的，表示针对性的操作。
- 常用方法：
list.append(obj) 追加元素
list.count(obj) 统计某个元素出现的次数
list.insert(index, obj) 将某个元素插入到指定位置
1）列表元素的查找
#列表元素的查找，增加，删除
print('----------------查找-------------------')
list1=['love',22,24,26,28,'pyton',True]
print(list1)
print(list1[0]) #通过序列号（从0开始）来查找对应列表中的第一个元素[下标0]
print(list1[1:4]) #输出列表中第2个到第5个元素[下标从1开始到第4]，包含下标1不包含下标4
print(list1[2:]) #输出列表中第3个之后所有元素[下标2开始后所有]
print(list1[::-1]) #倒序输出
print(2*list1)#复制
- 结果如下：
2）列表元素的增加
print('----------------增加-------------------')
list2=['python',1,2,3,4,True]
# append() 方法向列表的尾部添加一个新的元素
print('追加之前',list2)
list2.append(22) #追加单个元素
print('追加单个元素之后',list2)
list2.append([22,33,'abc']) #将整个列表作为一个元素插入
print('追加整个列表（作为一个元素）之后',list2)
# extend()方法只接受一个列表作为参数，并将该参数的每个元素都添加到原有的列表中。
list3=['python',1,2,3,4,True]
list3.extend([99,90])
print('添加列表中每个元素之后',list3) #添加每个元素
- 结果如下：
3）列表元素的删除
print('----------------删除-------------------')
# del
list4=[1,2,3,'python',True]
print('del删除之前',list4)
del list4[0]
print('del删除第一个元素之后',list4)
list4=[1,2,3,'python',True]
del list4[1:3]
print('del删除第2个到第4个元素之后',list4) #即删除下标为1,2的元素，不包括下标3
#remove() 移除指定的元素 参数是具体的数据值
list4=[1,2,3,'python',True]
print('remove删除之前',list4)
list4.remove(3)
print('remove删除数值为3的元素之后',list4)
list4.remove('python')
print('remove删除数值为python的元素之后',list4)
#pop() #移除指定的项 参数是索引值
list4=[1,2,3,'python',True]
print('pop删除之前',list4)
list4.pop(3)
print('pop删除下标为3的元素之后',list4)
- 结果如下：
4）列表元素的修改
print('----------------修改-------------------')
list5=[11,22,33,'python',True]
print('修改之前',list5)
list5[0]='我'
print('修改第一个元素之后',list5)
- 结果如下：
3、元组
3.1、关于元组
- 元组 tuple
Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号()，列表使用方括号[]。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
print('----------------------元组-----------------------')
tupleA=() #空元组
print(tupleA)
print(type(tupleA))
tupleB=(1,) #当元组中仅一个元素时，必须以逗号结尾才表示元组
print(tupleB)
tupleC=(1,2,3,'python',True)
print(tupleC)
- 结果如下：
3.2、元组的访问
元组也是序列，元组可以使用下标索引来访问元组中的值，如下实例:
print('----------------------元组查询访问-----------------------')
tuple1=(1,2,3,4,'python',True)
print(tuple1[0]) #访问第一个元素（即下标为0的元素）
print(tuple1[1:5]) #访问第第2到第6个元素（即下标1到下标5），不包括最后一个
print(tuple1[::-1]) #倒序访问
print(tuple1[::-2]) #倒序访问，每隔一个访问一次（即每两个访问一次）
print(tuple1[-4:-1]) #倒序访问，从倒数第4个到倒数第1个（即下标-4到-1），不包括最后一个
- 结果如下：
3.3、元组的修改
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，也可以修改元组中的列表元素，如下实例:
print('----------------------元组的修改-----------------------')
tuple1=(22,33,44,'python',True,[1,2,3])
tuple2=(1,2,3,'心情很好')
print(tuple1)
print(tuple2)
# tuple2[0]='我' #执行报错，不能单独修改元组元素
tuple1[5][1]=11 #修改元组tuple下标5（序列）中的第一个元素（下标为0）为11
print('修改元组tuple1中序列中的元素后',tuple1)
print(tuple1+tuple2) #通过‘+’拼接两个元组
print(2*tuple2) #元组的复制
- 结果如下
3.4、元组的删除
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
print('----------------------元组的删除-----------------------')
tuple1=(22,33,44,'python',True,[1,2,3])
print('删除之前',tuple1)
del tuple1
print('删除之后',tuple1) #删除之后报错，因为整个元组已经删除不存在了
- 结果如下：
4、字典
- 字典 也是python中重要的数据类型，字典是有 键值对 组成的集合，通常使用 键来访问数据，效率非常高，和list一样 支持对数据的添加、修改、删除
特点：
1：不是序列类型 没有下标的概念，是一个无序的 键值集合，是内置的高级数据类型
2：用{} 来表示字典对象，每个键值对用逗号分隔
3：键 必须是不可变的类型【元组、字符串】 值可以是任意的类型
4: 每个键必定是惟一的，如果存在重复的键，后者会覆盖前者
print('-------------------字典------------------------')
dict1={} #空字典
print(dict1,type(dict1))
dict1['name']='tom' #key : value(键值对)
dict1['sex']='男'
print(dict1)
dict1= {'name':'tom','sex':'男','age':10,'def':'程序员'} #声明字典时添加
print(dict1)
print('---------------一次定义多个数据类型，输出-----------------')
str1,list2,tuple3,dict4='I love python',[1,2,3,'python',True],(11,22,33,'python'),{'name':'tom','sex':'男'}
print(str1,type(str1))
print(list2,type(list))
print(tuple3,type(tuple3))
print(dict4,type(dict4))
- 结果如下：
4.1、字典的访问
通过键（key）来进行访问:
print('-------------------字典的访问------------------------')
dict1= {'name':'tom','sex':'男','age':10,'def':'程序员'} #声明字典时添加
print('通过name键访问姓名:',dict1['name']) #通过字典的键‘name' 来访问字典中对应元素
#获取字典所有键 dict.keys()
print('获取字典所有键:',dict1.keys())
#获取字典所有值 dict.values()
print('获取字典所有值:',dict1.values())
#获取字典所有键值对 dict.items()
print('获取字典所有键值对:',dict1.items())
#也可以通过for循环遍历输出
print('通过for循环输出:')
for key,value in dict1.items():
print('%s:%s'%(key,value))
- 结果如下：
4.1、字典的修改更新
print('-------------------字典的修改更新------------------------')
dict1= {'name':'tom','sex':'男','age':10,'def':'程序员'}
print('修改之前',dict1.items())
dict1['age']=32
print('修改age之后',dict1.items())
#通过update()方法更新或新增
dict1.update({'def':'高级程序员','pos':'四川'})
print('update修改并新增之后',dict1.items())
- 结果如下：
4.1、字典的删除
print('-------------------字典的删除------------------------')
dict1= {'name':'tom','sex':'男','age':10,'def':'程序员'}
print('删除之前',dict1.items())
del dict1['name']
print('del删除name之后',dict1.items())
dict1.pop('sex')
print('pop删除sex之后',dict1.items())
- 结果如下：
5、mysql知识扩展
- 关于左右连接后 and 和 where的区别
on比where起作用更早，先根据on条件进行多表的连接操作，生成一个临时表再通过where来筛选。（即on 后面的作为连接条件，而where是连接后做过滤筛选）
SQL> select * from t_user;
NAME BANJI XINGBIE NIANLING
----------- ----------- ----------- ---------------------------------------
张一 二班 男 18
张一 一班 女 22
张一 一班 男 18
李二 一班 女 19
张三 二班 男 20
李四 二班 女 18
王五 三班 男 19
刘六 三班 女 20
SQL> select * from chengji;
NAME KECHENG FENSHU
----------- ----------- ---------------------------------------
张三 语文 81
张三 数学 75
张三 英语 90
李四 语文 76
李四 数学 90
李四 英语 80
王五 语文 81
王五 数学 100
王五 英语 90
- and 条件 此时on 后面所有的and 都作为左连接的条件，左表中所有的学生均显示，右表只列出满足条件的（即右表分数大于等于90的）
SQL> select t1.name,t2.name,t1.banji,t2.fenshu from t_user t1 left join chengji t2 on t1.name=t2.name and fenshu >= 90;
- where 条件 由下面第一条语句可知，左连接的条件是 t1.name=t2.name and fenshu > 60，左表显示所有，右表显示满足条件的（成绩大于60）;而第二条语句左连接的条件仅有 t1.name=t2.name，此时会列出左表所有和右表满足on条件的，此时已经生成一个临时表，最后再通过where来过滤，则只会保留满足where条件的值。
SQL> select t1.name,t2.name,t1.banji,t2.fenshu from t_user t1 left join chengji t2 on t1.name=t2.name fenshu > 60;
SQL> select t1.name,t2.name,t1.banji,t2.fenshu from t_user t1 left join chengji t2 on t1.name=t2.name where fenshu >= 90;
参考资料： runob.
556
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
