学习之旅3-python高级数据类型

• 引入： 计算机是可以做数学计算的机器，因此，计算机程序理所当然地可以处理各种数值。但是，计算机能处理的远不止数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。在Python中，能够直接处理的数据类型有：数字、字符串、列表、元组、字典等。

• 关于序列： 在python当中 序列就是一组按照顺序排列的值【数据集合】
  在python中 存在三种内置的序列类型：字符串、列表、元组
  优点：可以支持索引和切片的操作
  特征：第一个正索引为0，指向的是左端，第一个索引为负数的时候，指向的是右端
  切片：【高级特性】可以根据下表来获取序列对象的任意[部分]数据
  语法结构：[start : end : step] step默认1

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.