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

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

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

Python-高级数据类型

  • 1、字符串操作
    • 1.1、 字符串常用方法
    • 1.2、字符串常用函数
    • 1.3、关于切片
    • 1.4、与其他类型综合操作
  • 2、列表及常用方法
    • 2.1、关于列表
    • 2.2、列表常用函数、方法
      • 1)列表元素的查找
      • 2)列表元素的增加
      • 3)列表元素的删除
      • 4)列表元素的修改
  • 3、元组
    • 3.1、关于元组
    • 3.2、元组的访问
    • 3.3、元组的修改
    • 3.4、元组的删除
  • 4、字典
    • 4.1、字典的访问
    • 4.1、字典的修改更新
    • 4.1、字典的删除
  • 5、mysql知识扩展

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))
  • 结果如下:

学习之旅3-python高级数据类型_第1张图片

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])
  • 结果如下:

学习之旅3-python高级数据类型_第2张图片

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)#复制
  • 结果如下:

学习之旅3-python高级数据类型_第3张图片

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-python高级数据类型_第4张图片

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)
  • 结果如下:

学习之旅3-python高级数据类型_第5张图片

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-python高级数据类型_第6张图片

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-python高级数据类型_第7张图片

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-python高级数据类型_第8张图片

3.4、元组的删除

元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组,如下实例:

print('----------------------元组的删除-----------------------')
tuple1=(22,33,44,'python',True,[1,2,3])
print('删除之前',tuple1)
del tuple1
print('删除之后',tuple1)  #删除之后报错,因为整个元组已经删除不存在了
  • 结果如下:

学习之旅3-python高级数据类型_第9张图片

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))
  • 结果如下:

学习之旅3-python高级数据类型_第10张图片

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))
  • 结果如下:

学习之旅3-python高级数据类型_第11张图片

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;

学习之旅3-python高级数据类型_第12张图片

  • 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;

学习之旅3-python高级数据类型_第13张图片

参考资料: runob.

你可能感兴趣的:(笔记,python,数据库)