python数据类型常见操作

目录

一、python常见的赋值方式

1.交互性赋值方式

2.连续性赋值方式

3.单独赋值方式

二、常用的数据类型之间的转换

三、 字符串中的常见操作(重点)

1、find   2、index   3、count   4、replace  5、split

6、capitalize  7、title  8、swapcase  9、startswith

10、endswith  11、lower  12、upper  13、ljust  14、rjust

15、center  16、lstrip   17、rstrip   18、strip  19、rfind

20、rindex  21、splitlines  22、isalpha  23、isdigit  24、isalnum

25、isspace  26、join  27、eval  28、len  29、chr  30、unichr

四、列表（重点）

1、列表的循环遍历

2、列表中常见的操作（非函数）

3. 列表中常见的操作（函数）

4. 列表中常见的函数

5.列表的嵌套

五、字典（重点）

1.字典的概述

2.字典的格式

3.根据键找值

4.get函数

5.字典中常见的操作

6.字典和列表优缺点

六、 集合

---

一、python常见的赋值方式

1.交互性赋值方式

a,b,c,d = 10,3.5,True,3+4j
print(a,b,c,d)
print(type(a),type(b),type(c),type(d))

2.连续性赋值方式

num = num2 = num3 = 10
print(num,num2,num3)
print(type(num),type(num2),type(num3))
print(id(num),id(num2),id(num3))

3.单独赋值方式

a = 5
b = 3.8
c = False
d = 10+5j
print(a,b,c,d)
print(type(a),type(b),type(c),type(d))
print(id(a),id(b),id(c),id(d))

 id(变量名) 获取变量内存地址
除了使用type(变量名)获取变量类型外 可以通过isinstance(变量名,预测的数据类型)获取变量类型

 str2 = 'hello'
 li = [1,3,5,7]
 print(isinstance(str2,str))
 print(isinstance(li,str))

它们之间的区别：
type(变量名)获取变量的数据类型,它不会认为子类和父类是相同的数据类型
isinstance(变量名,预测的数据类型)预测变量是什么类型,它会认为子类和父类是相同的数据类型

二、常用的数据类型之间的转换

函数	说明
int(x)	将x转换为一个整数
float(x)	将x转换为一个浮点数
complex（real,[,imag]）	创建一个复数
str(x)	将对象x转换为字符串
repr(x)	将对象x转换为表达式字符串 用的不多
tuple(x)	将序列转换为元祖
list(x)	将序列x转换为列表
chr(x)	将一个整数转换为一个字符
unichr(x)	将一个整数转换为unicode字符
ord(x)	将一个字符转换为整数
hex(x)	将一个整数转换为一个十六进制的字符串

ps：unicode为统一码

三、 字符串中的常见操作(重点)

如有一个字符串
myStr = "hello world"

1、find

定义：
    检测str是否包含在myStr中，如果是返回开始元素的索引值，否则返回-1   
 格式：
 myStr.find(str,start,end)

 2、index

定义：
   跟find方法一样，只不过如果str不在myStr中，或直接报错
格式：
   myStr.index(str,start,end)

3、count

定义：
    返回str在start和end直接在myStr中出现的次数
    
格式：
   myStr.count(str,start,end)

4、replace

replace:
定义：
    把myStr中str1(旧元素)替换为str2(新元素)，如果指定了count，则替换不超过count次

格式：
   myStr.replace(str1,str2,count)

5、split

split:
定义：
    分割，以str为分隔符切片myStr,
    返回的是列表（分割后的每一个元素作为列表中的元素（String）
    
格式：
myStr.split("",maxsplit)

6、capitalize

capitalize:
定义：
    把字符串中的第一个大写
格式：
   myStr.capitalize()

7、title

title:
定义：
    把字符串中的每一个单词的首字母大写
格式：
   myStr.title()

8、swapcase

swapcase
定义：
转换字符串中字母的大小写，小变大，大变小

9、startswith

startswith
定义：
    检查字符串是否以object开头，如果是返回True，反之返回False
    
格式：
    myStr.startswith(obj)

10、endswith

endswith
定义：
检查字符串是否以object结尾，如果是返回True，反之返回Flase

格式：
myStr.endswith(obj)

11、lower

lower
定义：
    转换myStr中所有大写字符为小写
 格式：
    myStr.lower()   

12、upper

upper
定义：
    转换myStr中所有小写字符为大写
 格式：
    myStr.upper()   

13、ljust 

ljust:
定义：
    返回一个原字符串左对齐，使用空格填充长度width,形成一个新的字符串
    
格式：
   myStr.ljust(width)
   width:表示字符串的长度
注意：
   如果长度没有原始的字符串的长度长，默认使用字符串的长度

14、rjust

rjust:
定义：
返回一个原字符串右对齐，使用空格填充长度width, 形成一个新的字符串

格式：
myStr.rjust(width)
width: 表示字符串的长度

15、center

center:
定义：
返回一个原字符串居中，使用空格填充长度width, 形成一个新的字符串

格式：
myStr.center(width)
width: 表示字符串的长度

16、lstrip 

lstrip:
定义:
    删除myStr左边的空白字符
    
格式:
  myStr.lstrip()

17、rstrip 

rstrip:
定义:
    删除myStr右边的空白字符

格式:
  myStr.rstrip()

18、strip

```
strip:
定义:
    删除myStr两端的空白字符

格式:
  myStr.strip()
```

19、rfind

rfind
定义:
   类似与find函数,从右边开始查找,如果找到返回元素的开始索引,反之返回-1
   
格式:
   myStr,rfind(str,start,end)

20、rindex

rindex:
定义:
   类似与index(),从右往左找,如果找到返回该元素的开始索引,反之直接报错
   
格式:
myStr.rindex(str,start,end)

21、splitlines

splitlines:

定义:
    按照行进行分割,返回一个包含每行作为元素的列表
格式:
  myStr.spiltlines()    
myStr = "hello \nworld \npython \npython"

22、isalpha

isalpha
定义:
   如果myStr所有的字符都是字母,返回True,反之返回False
   
格式:
   myStr.isalpha()

23、isdigit

isdigit
定义:
   如果myStr所有的字符都是数字,返回True,反之返回False

格式:
   myStr.isdigit()

24、isalnum

isalnum

定义:
   如果myStr中所有的字符是字母或者数字,返回True,返回false
   
格式:
  myStr.isalnum()

25、isspace

isspace
定义:
   如果myStr中只包含空格,返回True,返回False
   
格式:
  myStr.isspace()

26、join

join
定义:
   myStr中每一个字符后面都会插入str,构造出一个新的字符串(不包含最后一个)

格式:
  myStr.join(str)

27、eval

eval:
定义:
    函数用来执行一个字符串表达式，并返回表达式的值。
   
格式:
  eval(str)     

28、len

len:
定义:
   返回字符串的长度(字符个数)
   
格式:
  len(str)

29、chr

chr:
定义:
    函数使用一个范围range(256)内(0~255)整数作为参数,返回对应的字符
    ACSII码
    
 格式:
   chr(0~255)   

30、unichr

unichr:

定义:
unichr和chr一样,区别在于unichr返回的是unicode(将整数返回成unicode字符)

注意:
   如果是配对usc2的unicode,它的允许范围是range(65536),0x0000-0xFFFF
   如果是配对usc4的unicode,它的允许范围是range(1114112)
   
   如果提供的参数不在允许的范围内,则会报valueError异常
   
   注意:
     如果想要使用unichr,需要导入unichr模块中的idna
from idna import unichr

四、列表（重点）

1、列表的循环遍历

使用for循环

for n in nameList:
    print(n)

while循环

len = len(nameList)
i = 0
while i < len:
    print(nameList[i])
    i += 1

2、列表中常见的操作（非函数）

列表元素的访问
list = [1,2,3,4,5,10]
注意不要越界(下标超出了可表示的范围)

元素的替换
修改语法格式:列表变量名[下标] = 新的值
list[2] = 100
print(list)

列表的组合
list2 = [7,8,9]
print(list+list2)

列表的重复
print(list*3)

in判断元素是否在列表中,如果找到返回True,反之False
if 10 in list:
    print('True')
else:
    print('False')

截取(包左不包右)
print(list[0:3])

3. 列表中常见的操作（函数）

1.添加元素（append,extend,insert）

1.通过append函数可以向列表中添加元素

#定义一个变量nameList的类型为列表,默认有三个元素
nameList = ["xiaoming","xiaowang","xiaoli"]
print(nameList)
print('添加之前:')
nameList.append('xiaoqiang')
print(nameList)

2.extend:通过该函数可以向列表中添加元素

a = [1,2]
b = [3,4]
a.extend(b)
print(a)

3.insert(index,object):在指定的位置index前插入元素object

nameList.insert(1,'xiaoyao')
print(nameList)

2 修改元素
概述
修改元素的时候，要通过下标来确定需要进行的修改的元素，然后才能进行修改

a = [1,2,3,True,"hello"]

nameList[0] = 'daming'
print(nameList)

3 查找元素（in/not in/index/count）
查找元素（in,not in,index,count）
定义:
    查找:看看指定的元素是否存在
    
 python中查找的常见的方法
 in(存在):如果存在返回的结果为True,反之False
 not in(不存在):如果不存在结果为True,反之False

#根据键盘录入信息查找 某个人是否存在
name = input('请输入你要查找的姓名:')
if name not in nameList:
    print('存在')
else:
    print('不存在')

print(nameList.index('xiaoli'))

print(nameList.count('xiaoli'))

4.删除元素（del/pop/remove）

删除元素（del/pop/remove）
del:根据下标进行删除
pop:删除最后一个元素
remove:根据元素的值进行删除

international = ['中国','韩国','日本','美国']
del international[2]
international.pop()
international.remove('中国')
print(international)

5.排序sort

概述：
    sort将列表按照特定的顺序重新的排列，默认由小到大

li = [9,100,78,0,111,-3]
print(li)
li.sort()
print('排序之后结果:')
print(li)

#reverse()逆序
li.reverse()
print('逆序之后的结果是:')
print(li)

4. 列表中常见的函数

#len() 求列表元素个数
nameList = ['张三','李四','王五','赵六']
print(len(nameList))

#max() 获取列表元素最大值
list = [100,99,2,9999]
print(max(list))

#min() 获取列表元素最小值
print(min(list))

5.列表的嵌套

概述：
    类似while循环的嵌套，列表也支持嵌套
一个列表中元素为一个列表
格式：
   列表名 = [[],[],[]]
   
例如：
   schoolNames = [["清华大学"，"北京大学"],["工程大",'立信'],['合肥汽修院校']]

练习：
   一个学校，有3个办公室，现在有8个老师等待分配工位，请编写程序，完成随机分配
要求：
   办公室的编号，人数  具体是谁
    

#定义一个嵌套列表存储学校里面3个办公室
offices = [[],[],[]]
#定义一个列表存储8位老师的名字
nameList = ['张学友','刘德华','黎明','郭富城','王菲','张柏芝','张韶涵','杨颖']
import random
#循环获取每个老师的名字
for name in nameList:
    #使用随机数产生3个办公室
    index = random.randint(0,2)
    #offices[0] offices[1] offiices[2]
    offices[index].append(name)
print(offices)
i = 1  #办公室编号
for tempNames in offices:
    print('办公室%d的人数是%d'%(i,len(tempNames)))
    i += 1
    for name in tempNames:
        print('老师的名字是%s'%name)

五、字典（重点）

1.字典的概述

概述：  生活中的字典 新华字典 根据偏旁或者拼音找到对应页面
    
例如：
    学生信息列表，每一个学生有姓名，年龄，学号等

2.字典的格式

格式：
     {key:value,key:value....}
定义一个变量info为字典类型
info = {"name":"周杰伦","age":30,"address":"北京"}

说明：
   字典和列表一样，存储多种类型的数据
   列表中找某一个元素，根据下标找,默认下标从0开始
   字典中找元素，根据名字（就是:前面的那个值--》key）
   
字典：
   字典中的每一个元素分为两个部分，前面是键   后面是值
   例如：
      name   --------->   key
      周杰伦  --------->  value  

3.根据键找值

stu_info = {'name':'张三丰','age':30,'no':110}
print(stu_info)  #获取所有的元素值
获取单个元素值,获取姓名
name就相当于生活中新华字典 根据偏旁或者拼音查找对应某个汉字
语法格式:字典变量名[键的名字]
 print(stu_info['name'])
 print(stu_info['age'])

4.get函数

在我们不确定字典中是否存在某一个键而又想获取它的值，可以使用get(),可以设置默认值
res = stu_info.get('address','上海市')
print(res)

5.字典中常见的操作

修改元素

定义：
    字典的每一个元素中的数据是可以进行修改，只需要通过key找到，即可修改
   修改格式:
   变量名[修改键名] = 新的值   

 

#定义一个字典stu_info  存放学生学号 姓名 年龄
stu_info = {'no':110,'name':'张三','age':20}
#1.修改元素
#语法格式:字典变量名[对应键名] = 新的值
stu_info['age'] = 18
print(stu_info)
```

添加元素 

概述：
    访问不存在的元素的key 

#格式:
#变量名["键"] = 数据时,如果该键在字典中不存在,会自动创建

#添加手机号码
stu_info['mobile'] = 13248301214
print(stu_info)

删除元素
del  :删除指定的元素
clear()：清空字典

# del stu_info['age']  #删除字典中指定某个元素

#del stu_info   #删除字典所有元素  相当于内存里面删除
 stu_info.clear()  #删除字典所有元素,空字典 
 print(stu_info)

字典常见的函数的使用

#len():测量字典中,键值对的个数
print(len(stu_info))

#keys():返回一个包含字典中所有key的列表
print(stu_info.keys())

#values():返回一个包含字典中所有值value的列表
print(stu_info.values())

#items():返回一个包含所有(键   值)元祖的列表
print(stu_info.items())

字典的遍历
dict = {'name':'张三','age':20,'address':'上海市','no':110}

#1.获取字典中所有键名 keys()
 allkeys = dict.keys()
 for temp in allkeys:
     print(temp,end=' ')

#2.获取字典中所有的值 values()
 allValues = dict.values()
 print(allValues)
 for temp in allValues:
     print(temp,end=' ')

#3.获取字典中键值对
items = dict.items()
 print(items)
for key,value in items:
    print(key,value)

6.字典和列表优缺点

字典和列表比较：
1.查找和插入的速度较快，不会随着key-value的增加而变慢
2.需要占用较大的内存

列表占用空间小

六、 集合

1.集合的概述

集合与之前的列表和元祖类似，可以存储多种类型数据，这些数据不能重复
可以使用大括号 { } 或者 set()函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

格式:
    parame = {value1,value2...}
    或者
    set = set(value,value2...)

开发场景:去除重复的数据

理解：
   只有value,没有key
   
本质：
   无序，不重复元素的集合
   
   集合支持intersection(交集)，union(并集)，difference(差集)和sysmmetric difference(对称差集)等运算

2 集合的创建
集合的创建 ,需要列表/元祖/字典作为集合的元素
注意:重复的元素在集合中会被自动过滤掉

#1.set函数创建
 res = set([1,2])
 res = set({1:'hello',2:'world'})
 res = set((3,4))
 print(res)
 print(type(res))

#2.大括号创建{}
 fruit = {'apple','orange','banana'}
 print(fruit)
 print(type(fruit))

3 集合中常见的操作（添加/删除/遍历/交集/并集/差集）```
添加add

 set = set([1,2,3,4]) #集合的元素不能是数字
 set.add(5)
 set.add(5)  #不能添加重复的元素
 set.add([5,6])  #列表元素值可以修改
 set.add({5:'hello',6:'world'})  #字典元素值可以修改
 set.add((5,6))
 print(set)
 print(type(set))

#update()可以插入list/tuple/String打碎插入(无序,去重)
 set.update([5,6])
 set.update((7,8))
 set.update({9:'hello',10:'world'})
 set.update('0')
 print(set)

删除

 set.clear()
 print(set)

遍历for

 for temp in set:
     print(temp,end='')

交集/差集/并集 开发场景:好友之间的共同爱好
交集  &

s = set([1,2,3,4])
s2 = set([3,4,5,6])
print(s & s2)
print(s.intersection(s2))

并集  |

print(s | s2)
print(s.union(s2))

差集  -

print(s - s2)
print(s.difference(s2))

差集  对称差集

print(s.symmetric_difference(s2))