Python 基本数据类型

字符串

字符串英文 string ,是 python 中随处可见的数据类型,字符串的识别也非常的简单,就是用引号括起来的。

引号包括单引号 ' ' ,双引号 " " 和 三引号 ''' ''' ,比如 'abc' ,"123" 等等。

这里请注意,单引号 '' 或双引号 "" 本身只是一种表示方式,不是字符串的一部分,因此,字符串 'abc' 只有 a,b,c 这 3 个字符。

那么我们先来看下这三种方式,来定义同样内容的字符串,再把它打印出来,看看是怎样的。

str1 = '柯提'
str1 = "柯提"
str1 = '''柯提'''

print(str1)
print(str2)
print(str3)

打印出来的结果是一样的。

字符串操作

字符串的基本操作

x in s 如果 s 中的某项等于 x,那么结果为 True,否则为 False
x not in s 如果 s 中的某项等于 x,那么结果为 False,否则为 True
s + t s 与 t 相拼接
s * n 或 n * s 相当于 s 与自身进行 n 次拼接
s[i] s 的第 i 项,起始为 0,-1 为最后一个字符
s[i:j] s 从 i 到 j 的切片
s[i:j:k] s 从 i 到 j 步长为 k 的切片

字符串的常用方法

join

str.join(iterable)

str = ",".join("abcdefg")
print(str)

//输出
'a,b,c,d,e,f,g'

split

str.split(sep=None, maxsplit=-1)

返回一个由字符串内单词组成的列表。使用 , 作为分隔字符串

"a,b,c,d".split(",")

//输出
['a', 'b', 'c', 'd']

startswith

tr.startswith(prefix[, start[, end]])

如果字符串以指定的 prefix 开始,那么返回 True,否则返回 False。

str = "a,b,c,d"
result = str.startswith("a")
print(result)

字符串所有方法: https://docs.python.org/zh-cn/3.10/library/stdtypes.html#string-methods

Lower

将字符串全体小写

newstr = string.lower()

str = "ABCD"
newstr = str.lower()
print(newstr)

// 输出
abcd

upper

将字符串全体大写

big_str = string.upper()

str = "abcd"
newstr = str.upper()
print(newstr)

// 输出
ABCD

find

返回想寻找的成员的位置

string.find(item)

注意:字符串里的位置是从左向右,以 0 开始的,空格也算。

str = "abcd"
position = str.find("b")
print(position)

// 输出
1

index

返回想寻找的成员的位置

string.index(item)

Python 字符串的编码问题

我们都知道计算机只能处理数字,如果要处理文本,就必须先把文本转换为数字才能处理。最早的计算机在设计时采用8个比特(bit)作为一个字节(byte),所以,一个字节能表示的最大的整数就是255(二进制11111111=十进制255),0 - 255被用来表示大小写英文字母、数字和一些符号,这个编码表被称为ASCII编码,比如大写字母 A 的编码是 65,小写字母 z 的编码是 122。

如果要表示中文,显然一个字节是不够的,至少需要两个字节,而且还不能和 ASCII 编码冲突,所以,中国制定了 GB2312 编码,用来把中文编进去。

类似的,日文和韩文等其他语言也有这个问题。为了统一所有文字的编码,Unicode 应运而生。Unicode 把所有语言都统一到一套编码里,这样就不会再有乱码问题了。

Unicode 通常用两个字节表示一个字符,原有的英文编码从单字节变成双字节,只需要把高字节全部填为 0 就可以。

因为 Python 的诞生比 Unicode 标准发布的时间还要早,所以最早的 Python 只支持 ASCII 编码,普通的字符串 ‘ABC’ 在 Python 内部都是 ASCII 编码的。

Python 在后来添加了对 Unicode 的支持,以 Unicode 表示的字符串用u'...'表示。

不过在最新的 Python 3 版本中,字符串是以 Unicode 编码的,也就是说,Python 的字符串支持多语言。就像上面的例子一样,我的代码中没有加 u'...',也能正常显示。

不过由于 Python 源代码也是一个文本文件,所以,当你的源代码中包含中文的时候,在保存源代码时,就需要务必指定保存为 UTF-8 编码。当 Python 解释器读取源代码时,为了让它按 UTF-8 编码读取,我们通常在文件开头写上这两行:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

第一行注释是为了告诉 Linux/OS X 系统,这是一个 Python 可执行程序,Windows 系统会忽略这个注释;

第二行注释是为了告诉 Python 解释器,按照 UTF-8 编码读取源代码,否则,你在源代码中写的中文输出可能会有乱码。

申明了 UTF-8 编码并不意味着你的 .py 文件就是 UTF-8 编码的,必须并且要确保文本编辑器正在使用 UTF-8 without BOM 编码。

字符串的格式化

字符串格式化使用操作符 % 来实现

'my name is %s, my age is %s' % ('zhangsan', 18)

字符串格式化函数 format

info = 'my name is {0}, my age is {1}, my book is {2}'
print(info.format("zhangsan", 18, "python"))

f-strings

name = "zhangsan"
age = 18
info = f'my name is {name}, my age is {age}'
print(info)

转义字符

符号 说明
\n 换行,一般用于末尾,strip对其也有效
\t 横向制表符(可以认为是一个间隔符)
\v 纵向制表符(会有一个男性符号)
\a 响铃
\b 退格符,将光标前移,覆盖(删除前一个)
\r 回车
\f 翻页(几乎用不到,会出现一个女性符号)
\\' 转义字符串中的单引号
\\" 转义字符串中的双引号
\\\ 转义斜杠

整数

整数英文为 integer 。代码中的整数跟我们平常认识的整数一样,包括正整数、负整数和零,是没有小数点的数字。

Python 可以处理任意大小的整数,例如:1,100,-8080,0,等等。

当然,要注意了,如果数字你用引号括起来了,那就属于字符串,而不属于整数。比如 '100' , 这 100 是字符串,不是整数。

浮点数

浮点数的英文名是 float ,是指带小数的数字。

浮点数跟整数有很多类似的地方,但是浮点数是最折磨人的,也是最难让人捉摸透的。

就好比世界级的大佬 Herb Sutter 说的:「世上的人可以分为3类:一种是知道自己不懂浮点运算的;一种是以为自己懂浮点运算的;最后一种是极少的专家级人物,他们想知道自己是否有可能,最终完全理解浮点运算。

布尔值

布尔值和布尔代数的表示完全一致,一个布尔值只有 True 、 False两种值,要么是 True,要么是 False,在 Python 中,可以直接用 True、False 表示布尔值(请注意大小写),也可以通过布尔运算计算出来。

布尔值可以用 and、or 和 not 运算。

and 运算是与运算,只有所有都为 True,and 运算结果才是 True。

or 运算是或运算,只要其中有一个为 True,or 运算结果就是 True。

not 运算是非运算,它是一个单目运算符,把 True 变成 False,False 变成 True。

空值

基本上每种编程语言都有自己的特殊值——空值,在 Python 中,用 None 来表示。

列表 List

什么是 List

List (列表)是 Python 内置的一种数据类型。 它是一种有序的集合,可以随时添加和删除其中的元素,且列表中的元素可以重复。

在实际开发中,经常需要将一组(不只一个)数据存储起来,以便后边的代码使用。列表就是这样的一个数据结构。

如何创建 List

listname = [element1, element2, element3, ..., elementn]

其实列表就是用中括号 [] 括起来的数据,里面的每一个数据就叫做元素。每个元素之间使用逗号分隔。

不同于C,java等语言的数组,python的列表可以存放不同的,任意的数据类型对象。

list1=['张三', 'lisi', 123]

使用列表推导式创建列表,如:

[x for x in range(1, 10)]

如何访问 List 中的值

我们可以通过列表的下标索引来访问列表中的值,同样你也可以使用方括号的形式截取字符。

例如:

name = ['张三', '李四', '王五']

# 通过索引来访问列表
print(name[1])

# 切片操作
# 通过方括号的形式来截取列表中的数据
print(name[0:2]) // 左闭右开,从第 0 个开始取,取到第 2 个,但是不包含第 2 个。
print(name[1:-1])

如何更新 List

可以通过索引对列表的数据项进行修改或更新,也可以使用 append() 方法来添加列表项。

name = ['张三', '李四', '王五']

# 通过索引对列表的数据项进行修改或更新
name[1] = '李4'
print(name)

# 使用 append() 方法来添加列表项
name.append('小明')
print(name)

// 输出
['张三', '李4', '王五']
['张三', '李4', '王五', '小明']

如何删除 List 里面的元素

name = ['张三', '李四', '王五']

print(name)

# 使用 del 语句来删除列表的的元素
del name[2]
print(name)

// 输出
['张三', '李四', '王五']
['张三', '李四']

List 内置方法

len(list)

列表元素个数

max(list)

返回列表元素最大值

min(list)

返回列表元素最小值

list(seq)

将元组转换为列表

append

list.append(obj) 在列表末尾添加新的元素

Count

list.count(obj) 统计某个元素在列表中出现的次数

Insert

list.insert(index, obj) 在 index 位置插入 obj 元素

Pop

list.pop(index) 移除索引对应的元素并且返回该元素的值,不指定索引移除最后一个元素

remove

list.remove(obj) 移除列表中的一个元素(参数是列表中元素),并且不返回任何值

sort

list.sort([func]) 对原列表进行排序

Clear

list.clear 将当前列表清空

元组 Tuple

什么是元组

tuple 和 List 非常类似,但是 tuple 一旦初始化就不能修改,也就是说它也没有 append(),insert() 这样的方法,但它也有获取某个索引值的方法,但是不能赋值。

所以建议能用 tuple 代替 list 就尽量用 tuple 。

如何创建元组

元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。

tuple1=('张三','李四','王五',123,456)
tuple2='张三','李四','王五',123,456

创建空元组

tuple3=()

元组中只包含一个元素时,需要在元素后面添加逗号

tuple4=(123,)

如果不加逗号,创建出来的就不是 元组(tuple),而是指 123 这个数了。

这是因为括号 () 既可以表示元组(tuple),又可以表示数学公式中的小括号,这就产生了歧义。

所以如果只有一个元素时,你不加逗号,计算机就根本没法识别你是要进行整数或者小数运算还是表示元组。

因此,Python 规定,这种情况下,按小括号进行计算,计算结果自然是 123 ,而如果要表示元组的时候,就需要加个逗号。

如何访问元组中的值

元组下标索引也是从 0 开始,元组(tuple)可以使用下标索引来访问元组中的值。

#-*-coding:utf-8-*-

tuple1=('张三','李四','王五',123,456)
tuple2='张三','李四','王五',123,456

print(tuple1[1])
print(tuple2[0])

如何修改元组

可能看到这个小标题有人会疑问,上面不是说 tuple 是不可变的吗?这里怎么又修改 tuple 了。

那是因为元组中的元素值是不允许修改的,但我们可以对元组进行连接组合,还有通过修改其他列表的值从而影响 tuple 的值。

具体看下面的这个例子:

#-*-coding:utf-8-*-
list1=[123,456]
tuple1=('张三','李四','王五',list1)
print(tuple1)
list1[0]=789
list1[1]=100
print(tuple1)

// 输出
('张三', '李四', '王五', [123, 456])
('张三', '李四', '王五', [789, 100])

可以看到,两次输出的 tuple 值是变了的。

可以看到,tuple1 有四个元素,最后一个元素是一个 List ,List 列表里有两个元素。

当我们把 List 列表中的两个元素 124 和 456 修改为 789 和 100 的时候,从输出来的 tuple1 的值来看,好像确实是改变了。

但其实变的不是 tuple 的元素,而是 list 的元素。

tuple 一开始指向的 list 并没有改成别的 list,所以,tuple 所谓的“不变”是说,tuple 的每个元素,指向永远不变。注意是 tupe1 中的第四个元素还是指向原来的 list ,是没有变的,我们修改的只是列表 List 里面的元素。

如何删除元组

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

#-*-coding:utf-8-*-

tuple1=('张三','zhangsan',[123,456])
print(tuple1)
del tuple1

Tuple 内置方法

方法 描述
len(tuple) 计算元组元素个数
max(tuple) 返回元组中元素最大值
min(tuple) 返回元组中元素最小值
tuple(seq) 将列表转换为元组

集合 Set

python 的 set 和其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素。

set 和 dict 类似,但是 set 不存储 value 值的。

如何创建 set

创建一个 set,需要提供一个 list 作为输入集合

set1=set([123,456,789])
print(set1)

// 输出
{456, 123, 789}

传入的参数 [123,456,789] 是一个 list,而显示的 {456, 123, 789} 只是告诉你这个 set 内部有 456, 123, 789 这 3 个元素,显示的顺序跟你参数中的 list 里的元素的顺序是不一致的,这也说明了 set 是无序的。

还有一点,我们观察到输出的结果是在大括号中的,经过之前的学习,可以知道,tuple (元组) 使用小括号,list (列表) 使用方括号, dict (字典) 使用的是大括号,dict 也是无序的,只不过 dict 保存的是 key-value 键值对值,而 set 可以理解为只保存 key 值。

在 dict (字典) 中创建时,有重复的 key ,会被后面的 key-value 值覆盖的,而 重复元素在 set 中自动被过滤的。

如何更新 set

通过 add(key) 方法可以添加元素到 set 中,可以重复添加,但不会有效果

set1=set([123,456,789])
print(set1)
set1.add(100)
print(set1)
set1.add(100)
print(set1)

删除 set 里面的元素

通过 remove(key) 方法可以删除 set 中的元素

set1=set([123,456,789])
print(set1)
set1.remove(456)
print(set1)

字典 Dict

什么是 dict(字典)

字典是Python提供的唯一内建的映射(Mapping Type)数据类型。

如何创建 dict

字典是另一种可变容器模型,且可存储任意类型对象。

python使用 { } 创建字典,由于字典中每个元素都包含键(key)和值(value)两部分,因此在创建字典时,键和值之间使用冒号:分隔,相邻元素之间使用逗号,分隔,所有元素放在大括号{ }中。

格式如下所示:

dictname = {'key':'value1', 'key2':'value2', ...}

1、同一字典中的各个键必须唯一,不能重复。

2、字典是键值对是无序的,但在3.6版本后,字典默认做成有序的了,这是新的版本特征。

创建 dict(字典)实例:

dict1={'张三':'111111' ,'zhangsan':'222222' ,'sanzhang':'333333'}
dict2={'abc':1234,1234:'abc'}

如何访问 dict

name = {'张三': '131456780001', '李四': '131456780002', '王五': '131456780003', '赵六': '131456780004'}
print(name['李四'])

// 输出
131456780002

这里需要注意的一点是:如果字典中没有这个键,是会报错的。

如何修改 dict

向字典添加新内容的方法是增加新的键/值对,修改或删除已有键/值对

dict1={'张三':'131456780001' ,'李四':'131456780002' ,'王五':'131456780003'}
print(dict1)
# 新增一个键值对
dict1['jack']='444444'
print(dict1)
# 修改键值对
dict1['王五']='555555'
print(dict1)

删除 dict (字典)

通过 del 可以删除 dict (字典)中的某个元素,也能删除 dict (字典)

通过调用 clear() 方法可以清除字典中的所有元素

dict1={'张三':'111111' ,'李四':'222222' ,'王五':'333333'}
print(dict1)
# 通过 key 值,删除对应的元素
del dict1['张三']
print(dict1)
# 删除字典中的所有元素
dict1.clear()
print(dict1)

dict (字典)使用时注意的事项

  1. dict (字典)是不允许一个键创建两次的,但是在创建 dict (字典)的时候如果出现了一个键值赋予了两次,会以最后一次赋予的值为准
  2. dict (字典)键必须不可变,可是键可以用数字,字符串或元组充当,但是就是不能使用列表
  3. dict 内部存放的顺序和 key 放入的顺序是没有任何关系

和 list 比较,dict 有以下几个特点:

而list相反:

dict (字典) 的函数和方法

方法和函数 描述
len(dict) 计算字典元素个数
str(dict) 输出字典可打印的字符串表示
type(variable) 返回输入的变量类型,如果变量是字典就返回字典类型
dict.get("key",None) 查询字典某键的值,取不到返回默认值
dict.setdefault() 查询字典某键的值,取不到给字典设置键值,同时返回设置的值
dict.clear() 删除字典内所有元素
dict.update() 更新字典
dict.copy() 返回一个字典的浅复制
dict.values() 以列表返回字典中的所有值
dict.pop() 删除字典指定的键值对
dict.popitem() 随机返回并删除字典中的一对键和值
dict.items() 以列表返回可遍历的(键, 值) 元组数组
dict.keys() 返回字典所有 key 的伪列表
mail_list |= new_mail_list 用新字典的“键”和“值”更新旧的字典,新字典的“键”和“值”优先

字典进阶使用

# 案例1:列表嵌套字典

data = [
    {"name": "rain", "age": 22},
    {"name": "eric", "age": 32},
    {"name": "alvin", "age": 24},
]

# 循环data,每行按着格式『姓名:rain,年龄:22』将每个学生的信息逐行打印


for stu_dic in data:  # data是一个列表
    # print(stu_dic) #
    print("『姓名:%s,年龄:%s』" % (stu_dic.get("name"), stu_dic.get("age")))

# 将data中第二个学生的年龄查询出来

print(data[1].get("age"))

# 案例2:字典嵌套字典


data2 = {
    1001: {"name": "rain", "age": 22},
    1002: {"name": "eric", "age": 32},
    1003: {"name": "alvin", "age": 24},
}

# 循环data2,每行按着格式『学号1001, 姓名:rain,年龄:22』将每个学生的信息逐行打印

for stu_id, stu_dic in data2.items():
    # print(stu_id,stu_dic)
    name = stu_dic.get("name")
    age = stu_dic.get("age")

    print("『学号: %s, 姓名 %s,年龄:%s』" % (stu_id, name, age))

# name = "yuan"
# age = 22
# sex = "male"
#
# print("『姓名:", name, "年龄:", age, "性别:", sex, "』")
# print("『姓名: %s 年龄: %s  性别: %s 』" % (name, age, sex))
# print("姓名:name")

常见错误错误

  1. 访问错误

使用内置方法,访问到某个类型不存在的元素

解决办法:

先判断该元素是否存在,再进行操作

元素 in 对象

  1. 不同数据类型之间操作报错

不同的数据类型之间,能够支持不同功能但相同写法的元素符,如:

\> 、 <、 == 、+、 -

不同类型之间操作会出现报错,如:

1 + 'a'

TypeError: unsupported operatorted operand type(s) for +: 'int' and 'str'

解决办法:

转换为相同的类型

  1. 对只读类型进行写入

这种错误经常出现在元组类型中,如:

t.append('new_element')

AttributeError: 'tuple' object has no attribute 'append'

解决办法:

写入之前判断类型,type(t)

  1. 引用错误

常用于不可哈希对象作为字典的键

典型报错:TypeError: unhashable type: 'list'

解决办法:

使用元组、字符串、数字作为字典的键