python自定义数据类型score_python语法之基础数据类型

最新推荐文章于 2024-10-29 22:21:02 发布

张饭团

最新推荐文章于 2024-10-29 22:21:02 发布

阅读量6.1k

点赞数 1

文章标签： python自定义数据类型score

本文链接：https://blog.csdn.net/weixin_42514711/article/details/112990963

版权

本文详细介绍了Python中的基础数据类型，包括整型、浮点型、字符串的定义、用途、内置方法以及示例。同时，文章还涵盖了列表、元组、字典和集合的定义、操作方法及特点，帮助理解Python数据类型的使用和差异。

摘要由CSDN通过智能技术生成

一、整型

1、用途：一般用于定义整数，如：年龄，身份证号，qq号码等

2、定义方式：age = 18 ---->age = int( 18 )

3、内置常用方法 (用于数学计算与比较运算)

3.1 进制的转换

3.1.1其他进制转换10进制

二------->十： (0，1)110 1*(2**2)+ 1*(2**1) +0*(2**0)=4+2+0=6

print(int ( '110' ,2) )

八------->十： (0-7)123 1*(8**2)+ 2*(8**1) +3*(8**0)=64+16+3=83

print(int ( '123' ,8) )

十六------->十： (0-9，a-f )321 3*(16**2)+ 2*(16**1) +1*(16**0)=768+32+1=801

print(int ( '321' ,16) )3.1.2 10进制转换其他进制(0-9)

十------->二： print(bin (108 ) ) ------->0b1101100

十------->八： print(oct ( 83 ) )------->O0123

十------->十六： print(hex ( 1000 ) )------->Ox3e8

4、总结

1、(有索引的类型都是有序的)

2、不可变

3、存一个值

二、浮点型

1、用途：用于记录小数，身高，体重，薪资等

2、定义方式：height = 1.0 ----> height = float(1.0)

3、内置常用方法

s1 = '1.0'f1=float(s1)print(f1) #1.0

print(type(f1)) #float

a1 =int(f1)print(a1) #1

4、总结

1、无序

2、不可变类型

2、只能存一个值

三、字符串

1、用途：用于存储一些描述性信息，名字等

2、定义方式

第一种：

s1= '大象'第二种：

s2= "大象2"第三种：

s3= '''大象3'''s4= """大象4"""

print(s1,s2,s3,s4)#以上三种方式没有任何区别，但是不能混用

s5= '你今天"吃饭"了吗'

#补充：字符串前面加一个小写的r，代表转义

3、内置常用方法

1 1、索引取值(正向取、反向取)，只能取不能存2

3 s1 = 'hello world'

5 print(s1[4]) #正向取

6 print(s1[-7]) #反向取

8 2、索引切片：截取字符串中的一小段字符串9

10 print(s1[2:5])11 print(s1[4:])12 print(s1[:5])13 print(s1[0:-2:2])14 print(s1[::-1])15

16 3、成员运算：in not in

18 print("o" not ins1)19

20 4、strip :去除字符串左右两边的空格，中间不算21 input无论接受的是什么类型，一定返回的是字符串22

23 name = input(">>:").strip()24 print(len(name))25

26 a1 = '$$$$sean$$$'

27 print(a1.strip("$"))28

29 5、split : 切分: 对字符串进行切分，可以指定切分的分隔符，返回是一个列表30

31 a1 = 'sean 18 male'

33 print(a1.split())34

35 6、len() :获取当前数据中的元素的个数36

37 a1 = 'hello'

39 print(a1)40

41 #for循环

42 a1 = 'hello'

43 for i ina1:44 print(i)45

46 #需要掌握知识点：

47 strip，rstrip,lstrip48

49 inp = input(">>:").lstrip("*")50 print(inp)51 print(len(inp))52

54 #lower\upper

55 s1 = 'Hello world'

56 print(s1.upper())57 print(s1.lower())58

60 #startswith\endswith : 判断当前字符串是否以。。。开头，或者以。。结尾，返回的一定是布尔值

61 print(s1.startswith("He"))62

63 print(s1.endswith('ld'))64

65 .format()66 你的名字是：sean，你的年龄是：18

68 name = 'sean'

69 age = 19

71 print("你的名字是:",name,"你的年龄是,",age)72

73 print("你的名字是：{}，你的年龄是：{}".format(name,age))74

75 print("你的名字是：{1}，你的年龄是：{0}".format(name,age))76

77 print("你的名字是：{name}，你的年龄是：{age},{gender}".format(age=age,name=name,gender='male'))78

79 #f-string:

80 #通过大括号接收变量，在字符串前面一定要加一个小写f，，，，在python3.6以后才有

81 print(f"你的名字是：{name}，你的年龄是：{age}")82

83 #split\rsplit

84 s1 = "name,age,gender"

85 print(s1.split(",",1)) #可以指定切分的次数

87 #join : 将(列表)中每个元素按照前面字符串中的分隔符进行拼接

88 l1 = ['sean','18','male']89 print("|".join(l1))90

91 #replace：将字符串中的元素进行替换，参数，先老值，再新值

92 s1 = 'sean,18'

93 print(s1.replace("sean",'大象'))94

96 #isdigit() ：判断当前字符串中的数据，是否是一个数字，返回布尔值

98 score = input("please input your score:")99 ifscore.isdigit():100 score =int(score)101 if score >= 90:102 print('优秀')103 else:104 print("你tmd能不能好好输")

4、总结

1、有序

2、不可变类型

2、只能存一个值

四、列表

1、用途：用于存一个或者多个不同类型的值

2、定义方式：通过花括号存值，每个值之间通过逗号进行分隔

3、内置常用方法

#1、索引取值(正反都可以)，不仅可以取还可以存

l1 = [1, 2, 3, 4, 5]print(l1[2]) #3#l1[2] = 222#print(l1) # [1, 2, 222, 4, 5]#2、索引切片

print(l1[1:4]) #[2, 3, 4]#3、append() 追加只能添加到列表的最后一位,一次性只能添加一个值

l1.append(1000)print(l1)

l1.append([9, 8])print(l1)#4、insert() 插入值，通过索引指定插入的位置

l1.insert(3, 888)print(l1)#5、extend() 将插入的可迭代对象分别插入

l1.extend([33, 44, 55])print(l1)#6、reomve() 指定值删除，比较彻底,()中直接放值

l1.remove(1)print(l1)

l1.remove([9, 8])print(l1)#7、pop() 不传值，默认从最后开始删，指定索引删值,pop是有返回值的

val =l1.pop()print(val)

4、队列：先进先出

堆栈：先进后出

#队列

#l = []#l.append(1)#l.append(2)#l.append(3)#print(l)##[1, 2, 3]#l.pop(0)#print(l)##[2, 3]#l.pop(0)#print(l)##[3]#l.pop(0)#print(l)##[]

#堆栈

l=[]

l.append(1)

l.append(2)

l.append(3)print(l)#[1, 2, 3]

l.pop()print(l)#[1, 2]

l.pop()print(l)#[1]

l.pop()print(l)#[]

#深浅copy

importcopy

l1= [257, 'a', [4, 5, 6]]print(l1)print(id(l1))#print(id(l1[0]))

l2 = copy.deepcopy(l1) #[1, 'a', [4, 5, 6]]

l2[2][0] = 4444

print(l2)print(id(l2))print("l1:", l1)print("id_l1:", id(l1))

5、总结

1、有序

2、可变类型

2、存多个值

五、元祖 tuple

1、用途：用于存多个不同类型的值,不能存可变类型(列表)

2、定义方式：通过小括号存数据，数据之间用逗号分隔，值不可变，有索引。

#若容器里只有一个值，值的后面要加上逗号，否则返回字符串。

3、常用方法

#索引取值(正，反)

t = ('a','b','c','d')print(t[0]) #a

print(t[-1]) #d

#索引切片

print(t[0:2]) #('a', 'b')

#in/ not in

print('a' in t) #True

#len()

print(len(t)) #4

#for

for i int:print(i)#a#b#c#d

4、总结

1、有序

2、不可变类型

2、存多个值

六、字典 dict

1、用途：用于存多个不同类型的值,不能存可变类型(列表)

2、定义方式：通过花括号存数据，通过key：value来定义键值对数据，每个键值对中间用逗号分隔。

#key在定义时必须是不可变类型，value可以是任意类型。

三种定义方式：

#第一种

d1 = {'name':'nick', 'age':18}#第二种

d2 = dict('name':'nick', 'age':18)#第三种 zip

l1 = ['name','age']

l2= ['nick',18]

z1=zip(l1,l2)print(dict(z1)) #{'name': 'nick', 'age': 18}

3、方法

#按照key：value映射关系取值(可存可取)

d1= {'name': 'nick', 'age': 18}#print(d1['name']) #nick 取值

#d1['name'] = 'bonny'#print(d1) # {'name': 'bonny', 'age': 18} 改值

#d1['gender'] = 'male'#print(d1) # {'name': 'nick', 'age': 18, 'gender': 'male'} 添值

#in/ not in 默认判断key

print('name' in d1) #True

#len() 获取键值对的个数

print(len(d1)) #2

内置方法

#get() 获取key的值，若值不在，默认返回none

d1= {'name': 'nick', 'age': 18}#a= d1.get('xxx',123) #key不存在，可以设置默认返回值#print(a) #123

print(d1.get('age')) #18

print(d1.get('gender')) #None

#keys / values / items

print(d1.keys()) #['name', 'age'] 返回列表

print(d1.values()) #['nick', 18] 返回列表

print(d1.items()) #[('name', 'nick'), ('age', 18)] 返回列表套元祖，每一个item都是存在元祖

for key ind1:print(key)#name #默认遍历的是字典的key#age

for key ind1.keys():print(key)#name#age

for value ind1.values():print(value)#nick#18

for item ind1.items():print(item)#('name', 'nick')#('age', 18)

#pop 指定key删，有返回值，值为对应value

d1 = {'name': 'nick', 'age': 18}

a= d1.pop('name')print(d1) #{'age': 18}

print(a) #nick

#popitem() 随机删一组item，有返回值，值是元祖

d1.popitem()print(d1)#update() 用新字典替换旧字典，有则修改，无则添加

d1.update({'name':'peter'})print(d1) #{'name': 'peter', 'age': 18} 修改

d1.update({'b': 1})print(d1) #{'name': 'nick', 'age': 18, 'b': 1} 添加

#fromkeys() 生成一个新字典

d2 ={}

d2= d2.fromkeys([1, 2, 3], 'e')print(d2) #{1: 'e', 2: 'e', 3: 'e'}

#setdefault() key不存在时新增item，有返回值，返回新增value，key存在，返回对应value

d1 = {'name': 'nick', 'age': 18}

d3= d1.setdefault('d', 999)print(d3) #999

print(d1) #{'name': 'nick', 'age': 18, 'd': 999} key不存在时新增item有返回值

d4= d1.setdefault('name', 888) #key存在，返回对应value

print(d4) #nick

4、总结

无序

可变类型

存多个值

七、集合 set

1、用途：去重、关系运算

2、定义方式：通过大括号存储数据，每个元素通过逗号分隔.

定义空集合，必须使用set()来定义

# l1 = []

# s1 = ""

# d1 = {}

# ss1 = set() # 定义空集合

frozenset() 不可变集合

3、常用方法

s1 = {'a', 'b', 'c', 'd', 'e', 'e'}

s2= {'c', 'b', 'f', 'd', 'g'}print(s1) #{'a', 'c', 'b', 'd', 'e'} 去重

print(s1 | s2) #{'c', 'g', 'a', 'b', 'e', 'd', 'f'} 合集

print(s2 & s1) #{'d', 'b', 'c'} 交集

print(s1 - s2) #{'a', 'e'} 差集

print(s2 - s1) #{'g', 'f'} 差集

print(s1 ^ s2) #{'g', 'f', 'e', 'a'} 对称差集

print(s1 > s2) #False

print(s2 > s1) #Fals

4、总结

无序

可变

存多个值

八、总结

存一个值：整型、浮点型、字符串

存多个值：列表、元组、字典、集合

可变or不可变：

可变：列表，字典

不可变：整型、浮点型、字符串、元组、集合

有序or无序：

有序：字符串、列表、元组

无序：字典、集合

占用空间：

字典

列表

元组

集合

字符串

数字类型