python --03 (数据类型)

一、数值（number）

1.1 概念

在python3中，支持int float bool complex。数值数据类型的赋值和计算很直观，和我们大多数语言一样的。

1 整数(int)

包括正整数、负整数、零，没有小数点的数字，也可以使用十六进制、八进制显示。

小整数池的概念：

在Python中，小整数池是一个内置的机制，它确保了在CPython解释器中，对于某些特定范围内的整数，不同的变量可以同时指向同一个对象。这个范围默认是-5到256，但是可以通过Python源码修改这个范围。这个机制主要是为了优化内存和提升性能。

在python中不需要事先规定数据类型以此分配内存单元，所以在python中没有固定的取值范围，python存储的整数可以无限大、无限小。

2 浮点数(float)

就是小数，带有小数点的数。

inf 无限大

-inf 无限小

NaN 不是数字

a = float('inf')
b = float('-inf')
c = float('NaN')
print(a, b, c) #inf -inf nan

注意：计算机对于浮点数的计算是不精确的。保存在计算机中的都应该是二进制，而二进制对于整数的表示是精确的，对于小数的表示是不精确，只能非常接近这个数。

在进行浮点数的计算的时候，一定要特别小心

print(0.55 + 0.4) #0.9500000000000001
print(0.55 + 0.41) #0.96
print(0.55 + 0.411) #0.9610000000000001

3 布尔值（bool）

只有两个值 true false

a = 0
b = 10
c = a and b
print(c) #0
print(type(c)) #<class 'int'>

c = bool(a and b)
print(c) #False
print(type(c)) #<class 'bool'>

布尔值短路现象

# e = 100<200 and 50<(3/0)    #and    条件1为真  条件2需要判断
# print(e)

# e = 100>200 and 50<(3/0)  #and    条件1为假   条件2不需要判断
# print(e)

# e = 100<200 or 50<(3/0)     # or    条件1为真   条件2不需要判断
# print(e)

4 复数（complex）

复数由两部分——实部和虚部组成，用a+bj的形式表示，也可以使用内置函数complex(a,b)表示。其中a和b都是小数。

a = 3+4j
print(a) #(3+4j)
print(type(a)) #<class 'complex'>

b = complex(3,4)
print(b) #(3+4j)
print(type(b)) #<class 'complex'>

1.2 数字类型的转换

在使用Python语言中数据类型的转换分为显式转换和隐式转换，

隐式类型转换在程序计算的时候自动发生比如使用1.0+1最终隐式类型转换为浮点数2.0。

显式类型的转换可以使用以下函数完成

#练习1：输入一个单字符，判断是大写字母输出对应小写字母，
                    是小写字母输出对应大写字母，
                    是数字字符输出对应整数，
                    是其他字符直接输出。
s = input(">>")
if 'A'<=s<='Z':
    print(chr(ord(s)+32)) #先用ord转化成字符对应整数 然后再通过chr转化成对应的字符
elif 'a'<=s<='z':
    print(chr(ord(s)-32))
elif '0'<=s<='9':
    print(ord(s)-48)
else:
    print(s)

#练习2：输入一个字符串，循环遍历字符串，将其中的数字字符累加求和。
    例如：输入666，输出18
sum = 0
s = input(">>")
for i in s:
    if '0'<=i<='9':
       sum+=ord(i)-48
print(sum)

1.3 数学函数

‌内置函数‌：内置函数是Python自带的函数，不依赖于任何对象，可以直接在任何地方调用。常见的内置函数如len(), type(), max()等。内置函数用于执行一些通用的操作，比如获取序列的长度、找出最大值等‌。

‌内置方法‌：内置方法是与特定对象（如列表、字符串、字典、模块等）相关联的函数。它们的调用需要在特定对象上进行‌。

import math
print(abs(-10)) #10
print(max(1,12,3,4,5)) #12
print(min(1,12,3,-4,5)) #-4
print(pow(10,2)) #100
print(round(3.1415, 2)) #3.14

print(math.fabs(-3.1415)) #3.1415
print(math.ceil(4.1)) #5
print(math.floor(4.1)) #4
print(math.exp(1)) #2.718281828459045
print(math.log(100,10)) #2.0
print(math.log(8,2)) #3.0
print(math.modf(3.1415)) #(0.14150000000000018, 3.0)

二、字符串（string）

2.1 概念：

在python中用单引号或双引号引起来的内容。

s = 'hqyj666'
s = "hqyj666"
s = ''        #空字符串
s = ""        #空字符串
s = '     '   #空格字符串
s = "     "   #空格字符串
问：空串和空格串一样吗？、
    不一样，空串是什么都没有，空格也算字符

注意：

1. Python语言中，单引号与双引号都没有任何区别
2. 一对单引号中可以包含 双引号
3. 一对双引号中可以包含 单引号
4. 若想在单引号中包含单引号、双引号包含双引号，使用 \ 转义字符处理

2.2 字符串访问 

2.2.1 下标索引

遍历 

s = 'hello world'
#通过元素遍历
for i in s:
    print(i,end = " ")#h e l l o   w o r l d

#通过下标进行遍历
for i in range(len(s)):
    print(s[i],end = " ") #h e l l o   w o r l d 

2.2.2 序列与切片

序列支持切片，即：列表、元组、字符串、均支持进行切片的操作

切片：从一个序列中，取出一个子序列

语法：序列[起始下标：终止下标：步长]

在python中看见 [:] 一定是切片

表示从序列中，从指定的位置开始，以此取出元素，到指定的位置结束，得到一个序列：

• 起始下标：表示从何处开始，可以留空，留空视作从头开始
• 结束下标：（不含）表示何处结束，可以留空，留空视作截取到结尾
• 步长表示：依此取元素的间隔，可以留空 默认为1

mylist=[0,1,2,3,4,5,6,7,8,9]
a = mylist[1:4:1] #[1, 2, 3]  表示从索引1开始4结束 步长为1
mytuple = ("hello","and","world")
b = mytuple[:] #('hello', 'and', 'world') 表示打印全部内容等同于直接打印mytuple
mystr = "hello and world"
c = mystr[::2] #hloadwrd 表示从头开始末尾结束，补步长为2
e = mytuple[::-2]#('world', 'hello')表示从末尾开始，到开始结束步长为-2

2.3 字符串的相关函数

2.3.1 查询相关函数

fin() 和index()区别：find()未找到返回-1，index()未找到会报错

name = "hello and world"
a =name.find("and") #6 //如果是字符串则是字符串的起始位置

name = "hello and world"
a =name.index("and") #6 //如果是字符串则是字符串的起始位置

name = "hello and world"
a =name.find("python")
print(a) #-1

name = "hello and world"
a =name.index("python")
print(a) #error

2.3.2 转换函数

s = "Hello Horld python"
print(s.lower())#hello world python
print(s.upper())#HELLO WORLD PYTHON
print(s.title())#Hello World python
print(s.capitalize())#hello world python

s = "   Hello Horld python  "
print(s.strip()) #Hello Horld python

2.3.3 判断函数

练习题：
1、从键盘输入一串字符串，先将所有大写转换成小写，
再移除其中的非数字字母字符之后，判断是不是回文字符串

s = input(">>")
new_s = ""
s = s.lower()
for i in s:
    if i.isalnum():
        new_s+=i
if new_s == new_s[::-1]:
    print("是回文数")
else:
    print("不是回文数")

2.3.4 分割函数

s = 'hello and world'
s1 = s.partition('and')
print(s1,type(s1)) #('hello ', 'and', ' world') <class 'tuple'>

s2 = s.split('and')
print(s2,type(s2)) #['hello ', ' world'] <class 'list'>

s = ('hello '
     'and '
     'world')
s3 = s.splitlines()
print(s3,type(s3)) #['hello and world'] <class 'list'>

2.3.5 其他函数

s = 'hello and world and python'
print(s.count('h')) #2
print("_".join(s)) #h_e_l_l_o_ _a_n_d_ _w_o_r_l_d_ _a_n_d_ _p_y_t_h_o_n

将列表改成字符串形式显示

s = ['hello','and','world','and','python']
print(" ".join(s),type(s))#hello and world and python <class 'list'>

练习题：
输入一个字符串，将这个字符串按照单词反序。
例如：输入"this is a book" , 输出 "book a is this" 。
s = 'this is a book'
b = s.split(" ")[::-1]
print(" ".join(b)) #book a is this

列表和字符串一样，都属于有序序列[有下标索引]，有一些共同操作：

len + * max min 切片等

三、列表（list）

3.1 列表是什么

所谓的列表是由一些列按照顺序存储的元素组成，区别于C语言中的数组，可以存储多种类型的数据，其中元素之间是没有任何关系的。

注意：

1. 元素放在[]里面的，多个元素之间用 逗号 隔开
2. 列表的元素可以修改

3.2 定义列表

s = []
s2 = [1,2,3,4,]
s3 = [1,2,'a','b','c',True]
print(s3 , type(s3),len(s3))#[1, 2, 'a', 'b', 'c', True] <class 'list'> 6

s4 = [1,2,3,['hello','world']]
print(s4,type(s4),len(s4))#[1, 2, 3, ['hello', 'world']] <class 'list'> 4

3.3 列表访问

3.3.1 下标访问

3.3.2 切片访问

和字符串一样

L = ['a', 'b', 'c', 'd', 'e']
print(L[:])
print(L[::-1])
print(L[:5:2])

3.4 列表的增加

name = ['代公公','邢公公','韩公公','董公公']
print(name)#['代公公', '邢公公', '韩公公', '董公公']

name.append('金公公')
print(name)#['代公公', '邢公公', '韩公公', '董公公', '金公公']

name.insert(5,'朕')
print(name)#['代公公', '邢公公', '韩公公', '董公公', '金公公', '朕']

b = ['万岁','万岁','万万岁']
name.extend(b)
print(name)#['代公公', '邢公公', '韩公公', '董公公', '金公公', '朕', '万岁', '万岁', '万万岁']

3.5 列表的删除

del 删除列表对应下标的元素

语法：del 列表[下标]

n = [1,2,3,4,5,6] del n[5] #[1,2,3,4,5] 将下标为5的元素进行删除


pop 删除列表对应下标的元素（通过取出列表元素删除列表元素）

语法：列表.pop（下标）没有下标默认是最后一个

n = [1,2,3,4,5,6] n.pop(3) #[1,2,3,5,6] 将列表下标为3的内容取出进而删除列表元素 p = n.pop(3)#5 将pop取出的列表下标为3的元素返回给p #这里为什么是5呢 是因为pop已经取出一次3下标元素，5就会从4下标转移到3下标


remove 删除某元素在列表中第一个匹配项

语法：列表.remove(元素)

n = [1,2,3,2,4,5,6] n.remove(2)#[1,3,2,4,5,6] 删除元素2第一次出现的元素


clear 清空列表内容

语法：列表.clear()

n = [1,2,3,2,4,5,6] n.clear() #[] 清空列表所有的内容

3.6 列表的修改

修改元素的时候，要通过下标来确定要修改的是哪个元素，然后才能进行修改

name = ['张三', '李四', '王五', '小华', '小明']
name[3] = '123'
print(name) #['张三', '李四', '王五', '123', '小明']

3.7 列表的查找

3.8 列表的其他操作

num = [2,3,6,1,7,9,0]
num.reverse()
print(num)#[0, 9, 7, 1, 6, 3, 2]
num.sort() #升序
print(num)#[0, 1, 2, 3, 6, 7, 9]
num.sort(reverse=True) #降序
print(num)#[9, 7, 6, 3, 2, 1, 0]

l1 = [1,2,3,4,5,6]
l2 = l1
import copy
l3 = copy.deepcopy(l1)
print(id(l1),id(l2),id(l3)) #2484702679424 2484702679424 2484702966464

• l2是引用，和l1的内存地址一样，也就是l1和l2指向同一片内存地址
• l3是深拷贝，生成副本，是一个新对象，l1和l3内存地址不一样
• 也就是说l1是源文件，l2就是快捷方式，l3是复制粘贴后的副本

import copy
l1 = [1,2,3,4,5,6,['a','b','c']]
# 浅拷贝
l2 = l1.copy()
#深拷贝
l3 = copy.deepcopy(l1)
# 修改值
l1[0] = 66
l2[1] = 88
l3[2] = 99
print(l1) #[66, 2, 3, 4, 5, 6, ['a', 'b', 'c']]
print(l2) #[1, 88, 3, 4, 5, 6, ['a', 'b', 'c']]
print(l3) #[1, 2, 99, 4, 5, 6, ['a', 'b', 'c']]
l1[6][0] ='hello'
l2[6][1] ='and'
l3[6][2] ='world'
print(l1) #[66, 2, 3, 4, 5, 6, ['hello', 'and', 'c']]
print(l2) #[1, 88, 3, 4, 5, 6, ['hello', 'and', 'c']]
print(l3) #[1, 2, 99, 4, 5, 6, ['a', 'b', 'world']]
# 深拷贝与浅拷贝的对比
# 深拷贝：将原列表直接复制一份，生成一个新对象[列表]，和原列表的内存地址不一样，原列表修改，新列表不变
# 浅拷贝：将原列表的值复制一份，同时引用而不复制原列表的【可变对象】，原列表修改值，新列表值不变；原列表修改
# 可变对象，新列表可变对象也变
# 实际变成中，浅拷贝使用多，因为深拷贝完全复制一个新对象会存在资源浪费。

3.9 列表嵌套

在python中，我们是允许列表嵌套的，也就是一个列表中的所有元素都是列表。它的元素访问和一层列表略有区别，可能需要添加多个[]下标去访问。

num = [[1,'a'],[2,'b'],[3,'c']]
#取值
print(num) #[[1, 'a'], [2, 'b'], [3, 'c']]
print(num[0]) #[1, 'a']
print(num[0][1]) #a

#增加
num.append([4,'d'])
print(num) #[[1, 'a'], [2, 'b'], [3, 'c'], [4, 'd']]

#排序
num.sort()
print(num)#[[1, 'a'], [2, 'b'], [3, 'c'], [4, 'd']]

3.9.1 operator.itemgetter(需要获取的第几个元素)——获取多维数组中某个维度的元素值

num = [[3,'a'],[1,'b'],[2,'c']]
import operator
num.sort(key =operator.itemgetter(0),reverse=True) #按照第二维度第一个值
print(num) #[[3, 'a'], [2, 'c'], [1, 'b']]
num.sort(key = operator.itemgetter(1),reverse=True) ##按照第二维度第一个值
print(num) #[[2, 'c'], [1, 'b'], [3, 'a']]

3.10 列表推导式

语法：列表名 = [表达式 for 循环体]

eg:利用列表推导式方式生成：

方法一：
l = [i for i in range(1,10,2)]
方法二
l = [i for i in range(1,10) if i%2!=0]