Python 数据类型

Python中的数据类型，包括内置数据类型、获取数据类型、设置数据类型、设置特定的数据类型

内置数据类型

Ps 可以使用以下type()函数获取任何对象的数据类型，例如：print(type(变量名))

Boolean（布尔值）

Python中布尔值(Booleans)表示以下两个值之一：True 或 False，0 和 None 都为 false，其他的都为真。

在编程中，通常需要知道表达式是True还是False，可以执行Python中的任何表达式，并获得两个值之一，True或False。

比较两个值时，将对表达式求值，Python返回布尔值：

1
2
3

print(11 > 9)
print(12 == 9)
print(13 < 9)

在if语句中运行条件时，Python返回True 或 False：

a = 200
b = 33

if b > a:
    print("b 大于 a")
else:
    print("b 不大于 a")

Number（数字）

python3的数字类型包括

int（长整型）
float（浮点型）
complex（复数）

int（整型）

在Python 3里, 只有一种整数类型 , 不分整型和长整型。Python的整数类型与其它语言表示的整数类型不太相同, 其它语言整型的取值范围与机器位数有关, 例如, 在32位机器上，整型的取值范围约是-2^31到2^31, 在64位的机器上整型的取值范围约是-2^63到2^63。而 Python的整型能表示的数值仅与机器支持的内存大小有关，也就是说Pyhton可以表示很大的数，可以超过机器位数所能表示的数值范围。

1 2	a = 1 b = int(2)

float（浮点型）

Python中的浮点类型类似Java语言中的double 类型，是双精度浮点型，可以直接用十进制或科学计数法表示。十进制数形式，由数字和小数点组成,且必须有小数点,如0.123、12.85、26.98等；科学计数法形式，如:2.1E5、3.7e-2等。其中e或E之前必须有数字,且e或E后面的指数必须为整数。

精度是指描述一个数值的准确程度，在数学运算中，经常会用到近似数，近似数与原数值非常相近，但又不完全符合原数值，只能说在某种程度上近似。精度与近似数相似，也是用一个与原数值非常相近的数代替原来的数值。

1 2	a = 1.0 b = float(1)

complex（复数）

复数是一个实数和虚数的组合，一个复数是一对有序浮点型（x，y），表示为x+yj，其中x是实数部分，y是虚数部分。

复数在科学计算中得到广泛应用。Python语言支持复数类型，下面是Python语言有关复数的几个概念。

（1）虚数不能单独存在，它总是和一个值为0.0的实数部分构成一个复数；

（2）复数由实数部分和虚数部分构成；

（3）实数部分和虚数部分都是浮点型；

（4）虚数部分后面必须有j或J。

（5）表示虚数的语法：real+imagej

1
2
3

aa=123-12j
print aa.real  # output 实数部分 123.0  
print aa.imag  # output 虚数部分 -12.0

String（字符串）

一、String 概念

1. 什么是字符串？

字符串是以单引号或双引号括起来的文本
例如：
- 'abc'
- "abc123"

2. 如何创建字符串？

1 2	str1 = "lemon is a good man!" str2 = "sunck is a nice man!"

注意：字符串不可变！！！举例说明：

1
2
3

str3 = "*lemon*"
print(str3.strip("*"))      #lemon；这仅仅是strip返回的输出结果，而实际上并没有改变字符串
print("str3 = %s" % (str3)) #str3 = *lemon*；因为，字符串类型不可变！！！

二、string 方法

1. 字符串运算

1)字符串连接
str4 = "what "
str5 = "is "
str6 = "name?"
str7 = str4 + str5 + str6
print(f"str7 = {str7}")

2)输出重复字符串
str7 = "lemon"
str8 = str7 * 3
print(f"str8 = {str8}")

2. 字符串的截取

访问字符串中的某一个字符，通过索引下标查找字符，索引从0开始
从开始下标之后开始截取，截取到结束下标之前
格式：str 变量名[开始下标:结束下标]

# 只截取下标为 1 的字符串
str9 = "sunck is a good man!"
print(str9[1])

# 截取字符串中的一部分；从给定下标处开始截取给定下标之前
str10 = "sunck is a good man!"
str11 = str10[11:15]
print(f"str11 = {str11}")

# 从开头截取到给定下标之前
str12 = "sunck is a good man!"
str13 = str12[:5]
print("str13 = ", str13)

# 从给定下标处开始截取到结尾
str14 = "sunck is a good man!"
str15 = str14[16:]
print("str15 = ", str15)

3. 判断数据元素是否存在

#1 身份运算符:
str16 = "sunck is a good man!"
print("good" in str16)          # True
print("good" not in str16)      # False

#2 成员运算符:
gl_str = "lemon"
print("lemon" is gl_str)        # True
print("lemon" is not gl_str)    # False

4. 判断系列方法

#1 startswith("str")
# 功能：判断指定的字符串是否为开头；是返回True，否则返回False
str4 = "lemon is a very good"
print(str4.startswith("lemo"), str4.startswith("lemon"), str4.startswith("lemons"), str4.startswith("good"))        # 返回值：True True False False

#2 endswith("str")
# 功能：判断指定的字符串是否为结尾；是返回True，否则返回False
str5 = "lemon is a very good"
print(str5.endswith("od"), str5.endswith("good"), str5.endswith("goods"), str5.endswith("lemon"))         # 返回值：True True False False

#3 isalpha()
# 功能：判断标识符里的str是否都为字母；是返回True，否则返回False
str1 = "lemon is a very good"
str2 = "abcdefgklkiyjbmyzbxc"
print("str1 = %s" % str1.isalpha())      # 返回值：str1 = False
print("str2 = %s" % str2.isalpha())      # 返回值：str2 = True

#4 isdigit()
# 功能：判断标识符里的str是否都为数字；是返回True，否则返回False
str1 = "12345678@"
str2 = "123456789"
print("str1 = %s" % str1.isdigit())     # 返回值：str1 = False
print("str2 = %s" % str2.isdigit())     # 返回值：str2 = True

#5 isalnum()
# 功能：判断标识符里的str是否都为字母、数字、字母数字；是返回True，否则False
str1,str2,str3,str4,str5 = "lemon is very good", "lemon is 123123", "123456", "abcdefg", "123abc"
print("str1 = %s" % str1.isalnum())     # 返回值：str1 = False
print("str2 = %s" % str2.isalnum())     # 返回值：str2 = False
print("str3 = %s" % str3.isalnum())     # 返回值：str3 = True
print("str4 = %s" % str4.isalnum())     # 返回值：str4 = True
print("str5 = %s" % str5.isalnum())     # 返回值：str5 = True

#6 isspace()
# 功能：判断标识符里的str是否都为空格；是返回True，否则False
str1 = " "
str2 = ""
str3 = "bbb 222 @@@"
print("str1 = %s" % str1.isspace())    # 返回值：str1 = True
print("str2 = %s" % str2.isspace())    # 返回值：str2 = False
print("str3 = %s" % str3.isspace())    # 返回值：str3 = False

5. 格式化输出与转义字符

格式化输出功能
- 简化代码
常用的格式化输出符
- %d(整数)
- %f(浮点数)
- %s(字符串)

num1 = 10
f1 = 10.123456789         # 小数部分默认为六位，并且默认就会四舍五入
str1 = "lemon"
print("num1 = %d, f1 = %f, str1 = %s" % (num1, f1, str1))
print("num1 = %.3d, f1 = %.3f, str1 = %.3s" % (num1, f1, str1))
#【%.3d】：让这个整数值保留三位数，位数不够向前补0，如果够就保持原样
#【%.3f】：只保留小数的前三位，会四舍五入
#【%.3s】：只保留这个字符串的前三位

转义字符功能: \ 将一些字符转换成有特殊含义的的字符；常见的有\n \t 等等……

1)：\n  #换行符
print("lemon\n18")

num1 = 202
str1 = "lemon"
print("num1 = %d\nstr1 = %s" % (num1,str1))
print(f"num1 = {num1}\nstr1 = {str1}")

# 思考：如果字符串内有很多\n符，写在一行不好阅读怎么办？比如print('aaa\nbbb\nccc......\n')
# 解决方法1：
print("""
good
nice
hostname
""")

# 解决方法2：
num1 = 303
str1 = "lemon"
print("""
num1 = %d
str1 = %s
""" % (num1,str1))


2): \t   #制表符
print("101\tlemon")

num1 = 202
str1 = "lemon"
print("num1 = %d\tstr1 = %s" % (num1,str1))

# 思考：如果字符串中有好多字符串都需要转义，就需要加入好多\，为了简化，python允许用r表示内部的字符串默认不转义

# 比如：我就想打印“C:\Windows\tystem32\nppraiser”这个字符串内容，但是windown的路径正好有很多开头是n或t等等一些特殊字符怎么办？

# 解决方法1：
print(r"C:\Windows\tystem32\nppraiser")

# 解决方法2：
print("C:\\Windows\\tystem32\\nppraiser")


3): \\
# 例如：
print("101 \\ lemon")

num1 = 202
str1 = "lemon"
print("num1 = %d \\ str1 = %s" % (num1,str1))


4): \'      \"
print('what is you \'s name?')
print("what is you \"s name?")
# print('what is you 's name?')
# print("what is you "s name?")
# 如果不加\转义符就会报错

6. eavl(“str”)

功能：将里面的字符串当成有效的表达式来求值并返回结果

num1 = eval("110")
num2 = eval("110.1")
# <class 'int'> <class 'float'> 110 110.1
print(type(num1),type(num2),num1,num2)
# 101
print(eval("+101"))
# -101
print(eval("-101"))
# 11
print(eval("10 + 1"))
# 9
print(eval("10 - 1"))
# 30
print(eval("10 * 3"))
# 3.3333333333333335
print(eval("10 / 3"))
# 1
print(eval("10 % 3"))
# 1000
print(eval("10 ** 3"))
# 3
print(eval("10 // 3"))
# 如果10大于3就True，否则就False
print(eval("10 > 3"))
# 如果10小于3就True，否则就False
print(eval("10 < 3"))
# 如果10等于3就True，否则就False
print(eval("10 == 3"))
# 如果10大于等于3就True，否则就False
print(eval("10 >= 3"))
# 如果10小于等于3就True，否则就False
print(eval("10 <= 3"))

7. len(“str”)

功能：返回字符串的长度【字符个数】

# 19
print(len("my name is 'a lemon"))
# 20
print(len("my name is 'a lemon李"))
# 5
name = "lemon"
print(len(name))

8. count(str_name,[start],[and])

功能：返回字符串中 str 出现的次数，可以指定一个范围，默认是从头到尾

name = "what is you name is the lemon-民!"
# 2
print(name.count("is"))
# 1；从字符串的第八个下标开始到结尾
print(name.count("is",8,len(name)))

9. lower()

功能：转换字符串中大写字母为小写字母

1
2
3

name = "WHAT is YOU NAME LEMON-民!"
# what is you name lemon-民!
print(name.lower())

10. upper()

功能：转换字符串中小写字母为大写字母

1
2
3

name = "what IS you name lemon-民!"
# WHAT IS YOU NAME LEMON-民!
print(name.upper())

11. swapcase()

功能：转换字符串中小写字母为大写字母，大写字母为小写字母

1
2
3

name = "what IS you NAME lemon-Min!民"
# WHAT is YOU name LEMON-mIN!
print(name.swapcase())

12. capitalize()

功能：首字母大写，其他都为小写

1
2
3

name = "THEN is YOU name LEMON-mIN!民"
# Then is you name lemon-min!民
print(name.capitalize())

13. title()

功能：每个单词的首字母大写

1 2	name = "what is you name lemon-民!" print(name.title()) # What Is You Name Lemon-民!

14. center(width, fillchar)

功能：返回一个指定宽度的居中字符串，fillchar 为填充的字符串，默认空格填充

name = "what is you name lemon-民!"
print(name.center(40))               # what is you name lemon-民!
print(name.center(40, "*"))          # *******what is you name lemon-民!********
print(name.center(40, "*"), "#")     # *******what is you name lemon-民!******** #

15. ljust(width, fillchar)

功能：返回一个指定宽度的左对齐字符串，fillchar 为填充字符，默认空格填充

name = "what is you name lemon-民!"
print(name.ljust(40))               # what is you name lemon-民!
print(name.ljust(40, "&"))          # what is you name lemon-民!&&&&&&&&&&&&&&&
print(name.ljust(40, "%"), "*")     # what is you name lemon-民!%%%%%%%%%%%%%%% *

16. rjust(width, fillchar)

功能：返回一个指定宽度的右对齐字符串，fillchar 为填充字符，默认空格填充

name = "what is you name lemon-民!"
print(name.rjust(40))               # what is you name lemon-民!
print(name.rjust(40, "&"))          # &&&&&&&&&&&&&&&what is you name lemon-民!
print(name.rjust(40, "%"), "*")     # %%%%%%%%%%%%%%%what is you name lemon-民! *

17. zfill(width)

功能：返回一个长度为width的字符串，原字符串右对齐，前面补0

1 2	name = "what is you name lemon-民!" print(name.zfill(40)) # 000000000000000what is you name lemon-民!

18. find(name,[start],[and])

功能：从左向右检测name字符串是否包含在字符串中，可以指定一个范围，默认是从头到尾；得到的是第一次出现的开始下标，没有则返回-1

name = "what is you name is the lemon-民!"
print(name.find("is"))                        # 5
print(name.find("man"))                       # -1
print(name.find("is", 8, len(name)))          # 17；从字符串的第八个下标开始到结尾

19. rfind(name,[start],[end])

功能：从右向左检测name字符串是否包含在字符串中，可以指定一个范围，默认是从头到尾；得到的是第一次出现的开始下标，没有则返回-1

name = "what is you name is the lemon-民!"
print(name.rfind("is"))                      # 17
print(name.rfind("man"))                     # -1
print(name.rfind("is", 0, 15))               # 5；从0开始，截止到第15个下标结束

20. index(“str”, start=0, end=len(str))

功能：和 find() 一样,只不过如果 str 不存在的时候会报错

1
2
3

name = "what is you name is the lemon-民!"
print(name.find("man"))     # -1
print(name.index("man"))    # 报错；ValueError: substring not found

21. rindex(str, start=0, end=len(str))

功能：和 rfind() 一样,只不过如果 str 不存在的时候会报错

1
2
3

name = "what is you name is the lemon-民!"
print(name.rfind("man"))      # -1
print(name.rindex("man"))     # 报错；ValueError: substring not found

22. lstrip()

功能：截掉字符串左侧指定的字符，默认为空格

name1 = "               what is you name the lemon-民!"
name2 = "***************what is you name the lemon-民!"
print(name1.lstrip())            # what is you name the lemon-民!
print(name2.lstrip("*"))         # what is you name the lemon-民!

23. rstrip()

功能：截掉字符串右侧指定的字符，默认为空格

name1 = "what is you name the lemon-民!               "
name2 = "what is you name the lemon-民!***************"
print(name1.rstrip())            # what is you name the lemon-民!
print(name2.rstrip("*"), "@")    # what is you name the lemon-民! @

24. strip()

功能：截掉字符串左侧和右侧指定的字符，默认为空格

1 2	name = "********my name is lemon*********" print(name.strip("")) # my name is lemon

25. split(str=””,num)

功能：将字符串切割成列表，以 str 为分隔符截取字符串，指定 num，则仅截取第 num 个字符串
示例1

1
2
3

str1 = "my*name*is*a*lemon"
print(str1.split("*"))        # ['my', 'name', 'is', 'a', 'lemon']
print(str1.split("*",3))      # ['my', 'name', 'is', 'a*lemon']

示例2

list1 = str1.split("*")
c = 0
for i in list1:
    if len(i) > 0:  # 统计list1列表的长度
        c += 1
print(c)            # 5；打印list1列表的元素数量

26. splitlines([keepends])

功能：按行将字符串切割成列表，如果 keepends == True ,会保留换行符，默认False

str2 = """lemon is a good man!
lemon is a nice man!
lemon is handsome man!
"""

print(str2.splitlines())
# 结果 ['lemon is a good man!', 'lemon is a nice man!', 'lemon is handsome man!']
print(str2.splitlines(True))     
# 结果 ['lemon is a good man!\n', 'lemon is a nice man!\n', 'lemon is handsome man!\n']

27. join()

功能：以指定的字符串为分隔符，将列表中的所有元素组成一个字符串

list = ["lemon", "is", "a", "good", "man"]
str = " *_* ".join(list)

print(str, type(str))         # lemon *_* is *_* a *_* good *_* man  <class 'str'>

28. max() min()

功能：max 找出最大的一位字符串（z）最大；min 找出最小的一位字符串（A）最小。

1
2
3

str = "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM"
print(max(str))        # z
print(min(str))        # A；如果有空格，空格就是最小的

29. replace(oldstr, newstr, count)

功能：用 newstr 替换 oldstr ，默认是全部替换。如果指定了 count ，那么则指替换前 count 个
示例：【字符串不可变】

str1 = "my name is a lemon lemon lemon"
print(str1.replace("lemon", "red"))        # my name is a red red red
print(str1.replace("lemon", "red", 2))     # my name is a red red lemon
print("str1 = %s" % (str1))                # 字符串不可变!!!

# str2、str3只不过是利用str1对他们自身赋值，其实并没有改变str1，因为，字符串不可变！
str2 = str1.replace("lemon","blue")
print("str2 = %s" % (str2))                # str2 = my name is a blue blue blue

str3 = str1.replace("lemon","blue",2)
print("str3 = %s" % (str3))                # str3 = my name is a blue blue lemon
print("str1 = %s" % (str1))                # str1 = my name is a lemon lemon lemon

30. maketrans(“str1”, “str2”) translate(identifier)

功能：将字符串1转换成字符串2

str1 = str.maketrans("ai", "65")   # 要转换的字符串   目标字符串   a--6   i--5
str2 = "my name is a lemon"
str3 = str2.translate(str1)
print(str3)                        # my n6me 5s 6 lemon

List 列表

一、List概念

1. 什么是列表？

列表本质
- 是一种有序的集合，并且列表是可变的
- 而且列表中的元素可以是不同类型的
列表就是用中括号将一个或多个元素括起来的数据列表
- 例如：
  - [1]
  - [“lemon”]
  - [1, “lemon”]

2. 如何创建列表？

格式：
- 列表名 = [列表选项1, 列表选项2, 列表选项3,……列表选项n]
示例：

# 创建一个空列表
list1 = []
print(list1)

# 创建一个带有元素的列表
list2 = [10, 20, 30, 40, 50]
print(list2)

# 列表中的数据可以是不同类型
list3 = [10, 10.1, "nice", True, False]
print(list3)

思考：要存储5个人的年龄并求出平均值
解决方法：使用列表

list4 = [10, 20, 30, 40, 50]
index = 0
sum = 0
while index < 5:
    # [index]是list列表的下标
    sum += list4[index]
    index += 1
    if index == 5:
        print("总和年龄：%d" % (sum))
        print("平均年龄：%d" % (sum / index))

二、列表元素的访问

1. 取值

功能：指定取出列表中的元素值，默认取出所有元素值
格式：列表名[下标]
注意：不要越界（下标不能超出可表示的范围，否则会报错）
示例：

1 2	list5 = [1, 2, 3, 4, 5] print(list5[2])

2. 替换

功能：替换掉列表中的元素
格式：列表名[下标] = value
示例：

1
2
3

list6 = [1, 2, 3, 4, 5]
list6[2] = 300
print(list6)

三、列表操作

1. 列表组合

示例：

list7 = [1, 2, 3]
list8 = [4, 5, 6]
list9 = list7 + list8
print("list7 = %s, list8 = %s, list9 = %s" % (list1, list2, list3))

注意： list7 和 list8 列表的元素不会变，我们不过是用了这两个列表定义了一个新的 list9 列表

2. 列表重复

示例：

1 2	list10 = [10, 20, 30] print(list10 * 2)

3.判断元素是否在列表中

示例：
- 判断 list11 列表里有没有 {5 6} 这两个元素，如果有返回 True，没有返回 False

1
2
3

list11 = [1, 2, 3, 4, 5]
print(5 in list11)        # True
print(6 in list11)        # False

4. 列表截取

功能：从开始下标之后开始截取，截取到结束下标之前
格式：列表名[开始下标:结束下标]
示例：

list12 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list12[2:])
print(list12[:6])
print(list12[2:6])

5. 二维列表

逻辑：这个 list 列表中的元素从某种意义上也是一个列表；无限制嵌套元素列表
示例：

list13 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(list13)          # [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(list13[1])       # [4, 5, 6]
print(list13[1][1])    # 5

四、列表方法

大部分和前面字符串的方法一样

1. append()

在 list 列表末尾追加一个新的元素值；但是一次只能追加一个新元素！
示例

list = [1, 2, 3, 4, 5]
print(list)

list.append(6)
print(list)

list.append([7,8,9])
print(list)

2. extend()

在 list 列表的末尾一次性追加另一个列表中的多个元素值；这个方法可以追加多个元素
示例

1
2
3

list = [1, 2, 3, 4, 5]
list.extend([6, 7.1, "lemon"])
print(list)

3. insert()

在下标处插入一个元素，也就是在下标处的前面插入一个元素，并且原下标向后顺延；但一次只能插入一个！
格式：列表名.insert(下标, 值)
示例

list = [1, 2, 3, 4, 5]
list.insert(0, -1)
print(list)
list.insert(0, [10, 20])
print(list)

4. pop()

移除列表中指定下标处的元素，默认移除最后一个元素，并可以返回被删除的数据
示例

list = [1, 2, 3, 4, 5]
list.pop()
print(list)               # [1, 2, 3, 4]
list.pop(2)
print(list)               # [1, 2, 4]
print(list.pop(1), list)  # 2 [1, 4]；返回被删除的元素值

5. remove()

只删除列表中指定元素的第一个匹配的结果，后面如果再出现相同元素，一律忽略；{不是以下标筛选元素}
示例

list = [1, 2, 3, 4, 5, 4, 7, 4]
list.remove(4)
print(list)               # [1, 2, 3, 5, 4, 7, 4]
list.remove(4)
print(list)               # [1, 2, 3, 5, 7, 4]

6. clear()

清除列表中所有的元素
示例

1
2
3

list = [1, 2, 3, 4, 5]
list.clear()
print(list)                # []

7. index()

从列表中找出某个元素值的第一个匹配的索引值
示例

list = ["a", "b", "c", "d", "e", "d", "g", "d", "i", "d"]
index1 = list.index("d")
index2 = list.index("d", 8)                        # 从第八个下标开始
print(f"index1 = {index1}\nindex2 = {index2}")     # index1 = 3, index2 = 9

8. count()

查看列表中的元素值出现过多少次
示例

1 2	list = [1, 2, 3, 4, 5, 3, 3, 5, 3] print(list.count(3)) # 4

案例
- 如何将下面的 list 列表中的 {3} 全部一次性删除

gc_list = [3, 2, 3, 4, 5, 3, 3, 5, 3]
# print(gc_list.count(3))             # 5
num1 = 0
all = gc_list.count(3)
while num1 < all:
    gc_list.remove(3)
    num1 += 1
print(gc_list)                        # [2, 4, 5, 5]

9. len()

统计列表中的元素总数
示例

1 2	list = [1, 2, 3, 4, 5] print(len(list))

10. max() min()

获取列表中的（最大、最小）值
示例

list = [1, 2, 3, 4, 5]

print(max(list))

print(min(list))

11. reverse() 倒序

示例

list = [1, 2, 3, 4, 5]

list.reverse()

print(list)

12. sort 排序升序

示例

list = [2, 1, 3, 4, 5]

list.sort()

print(list)       # [1, 2, 3, 4, 5]

13. 拷贝

有两种：
- 浅拷贝（引用拷贝）
- 深拷贝（内存的拷贝）
浅拷贝示例

list1 = [1, 2, 3, 4, 5]
list2 = list1
list2[1] = 200
print(list1)              # [1, 200, 3, 4, 5]
print(list2)              # [1, 200, 3, 4, 5]
print(id(list1))          # 2970263183944
print(id(list2))          # 2970263183944

深拷贝示例

list1 = [1, 2, 3, 4, 5]
list2 = list1.copy()
list2[1] = 200
print(list1)              # [1, 2, 3, 4, 5]
print(list2)              # [1, 200, 3, 4, 5]
print(id(list1))          # 1849288122952
print(id(list2))          # 1849288123016

14. list 去重复

因为set本身是无序和无重复元素的集合，所以默认会把重复的元素清理掉，从而在将set转换成list列表
示例

1
2
3

list = [1, 2, 3, 2, "lemon", "lemon"]
list = list(set(list))
print("list = %s " % list, type(list))    # list = [1, 2, 3, 'lemon']  <class 'list'>

15. 将元组转成列表

示例1

1 2	list1 = list((1, 2, 3, 4)) print(list1) # [1, 2, 3, 4]

示例2

1
2
3

tuple1 = (1, 2, 3, 4, 5)
list1 = list(tuple1)
print(list1)                # [1, 2, 3, 4, 5]

五、列表的遍历

list = ['html', 'js', 'css', 'python']

# 方法1
print('遍历列表方法1：')
for i in list:
    print ("序号：%s   值：%s" % (list.index(i) + 1, i))

print ('\n遍历列表方法2：')
# 方法2
for i in range(len(list)):
    print ("序号：%s   值：%s" % (i + 1, list[i]))

# 方法3
print ('\n遍历列表方法3：')
for i, val in enumerate(list):
    print ("序号：%s   值：%s" % (i + 1, val))


# 输出结果
遍历列表方法1：
序号：1   值：html
序号：2   值：js
序号：3   值：css
序号：4   值：python

遍历列表方法2：
序号：1   值：html
序号：2   值：js
序号：3   值：css
序号：4   值：python

遍历列表方法3：
序号：1   值：html
序号：2   值：js
序号：3   值：css
序号：4   值：python

Tuple（元组）

一、Tuple概念

1. 什么是元组

元组本质
- 是一种有序集合
- 而且元组中的元素可以是不同类型的
元组特点
- 与列表非常相似
- 一旦初始化就不能修改。{元组不可变}
元组就是用大括号将一个或多个元素括起来的数据列表
- 例如：
  - (1)
  - (“lemon”)
  - (1, “lemon”)

2. 如何创建元组？

格式：
- 元组名 = (元组元素1，元组元素2，元组元素3, ……, 元组元素n)
示例

# 创建空的元组
tuple1 = ()
print(tuple1)    # ()


# 创建带有元素的元组
tuple2 = (1, 1.2, "lemon", True)
print(tuple2)      # (1, 1.2, 'lemon', True)


# 定义只有一个元素的元组, 注意必须加上逗号，如果不加，他的本质就不是元素而是数字
tuple3 = (1, )
print(tuple3, type(tuple3))     # (1,) <class 'tuple'>

二、元组的操作

1. 取值

格式：
- 元组名[下标] #下标从0开始
示例

tuple4 = (1, 2, 3)
print(tuple4[0:])    # (1, 2, 3)
print(tuple4[:3])    # (1, 2, 3)
print(tuple4[0])     # 1
print(tuple4[1])     # 2
print(tuple4[2])     # 3
# print(tuple4[3])   # 下标超过范围(越界)，会报错！
print(tuple4[-1])    # 3；获取元组中倒数第一个元素
print(tuple4[-2])    # 2；获取元组中倒数第二个元素
# print(tuple4[-4])  # 同理，下标超过范围(越界)，会报错！

2. 修改

元组不可变，但它可以修改它里面元素的值，比如（list、dict）
示例

tuple5 = (1, 2, 3, [4, 5, 6])
# tuple5[0] = 100      # 报错，元组中的元素不能变，但是可以修改元组中元素列表中的值
tuple5[3][0] = 400
print(tuple5)
tuple5[3][-2] = 500
print(tuple5)
tuple5[-1][-1] = 600   # -1 就是最后一位下标的意思
print(tuple5)

3. 删除元组

del
格式：
- del 元组名
示例

1
2
3

tuple6 = (1, 2, 3)
del tuple6
print(tuple6)       # 报错：NameError: name 'tuple6' is not defined；找不到这个元组

4. 元组相加

示例

t1 = (1, 2, 3)
t2 = (4, 5, 6)
print(t1 + t2)     # (1, 2, 3, 4, 5, 6) 
t3 = t1 + t2
print(t3)          # (1, 2, 3, 4, 5, 6)

5. 元组重复

示例

1 2	t4 = (1, 2, 3) print(t4 * 2) # (1, 2, 3, 1, 2, 3)

6. 判断元组里的某个元素是否存在

1
2
3

t5 = (1, 2, "lemon")
print("lemon" in t5)    # True
print(3 in t5)          # False

7. 元组的截取

从开始下标之后开始截取，截取到结束下标之前
格式：元组名[开始下标:结束下标]
示例

t6 = (1, 2, 3, 4, 5, 6, 7, 8)

print(t6[1:6])    # (2, 3, 4, 5, 6)
print(t6[1:])     # (2, 3, 4, 5, 6, 7, 8)
print(t6[:5])     # (1, 2, 3, 4, 5)

8. 二维元组

示例

t7 = ((1, 2, 3),(4, 5, 6),(7, 8, 9))

print(t7)                 # ((1, 2, 3), (4, 5, 6), (7, 8, 9))
print(t7[1], t7[1][1])    # (4, 5, 6) 5

9. 将列表转成元组

示例

1
2
3

list = [1, 2, 3, 4, 5]
t4 = tuple(list)
print(t4)               # (1, 2, 3, 4, 5)

三、元组的方法

1. len()

返回元组中元素的个数
示例

1 2	t1 = (1, 2, 3, 4, 5) print(len(t1)) # 5

2. max() min()

max 返回元组中元素的最大值
min 返回元组中元素的最小值
示例

t2 = (1, 2, 3, 4, 5)

# max()
print(max(t2))         # 5
print(max((10, 20, 30, 40, 50)))     # 50

# 3)min()
print(min(t2))         # 1
print(min((10, 20, 30, 40, 50)))     # 10

3. 元组的遍历

示例

1
2
3

tuple1 = (1, 2, 3, 4)
for i in tuple1:
    print(i)

Dict（字典）

一、Dict 概念

1. 什么是字典？

字典本质
- 键-值(key-value)存储单位
- 字典具有极快的查找速度
- 一个字典里可以存储多个键-值 {字典是可变的}
- 字典是无序的！
key的特性
- 字典中的key必须唯一
- key必须是不可变对象（字符串、整数等都是不可变的，可作为key）（list列表是可变的，不能作为key）
字典就是用花括号将一个或多个 key-value 括起来的存储单位
左侧是key，右侧是value
例如
- {1:”lemon”}
- {2:”tools”, “lemon”:3}
dict 和 list 比较
dict
- 优点：查找和插入的速度极快，不会随着key-value的增加而变慢
- 缺点：需要占用大量的内存，内存浪费多
- list
- 优点：占用空间小，浪费的内存小
  - 缺点：查找和插入的速度会随着数据量的增多而减慢

2. 如何创建字典？

格式
- 字典名 = {键值对1, 键值对2, 键值对3, 键值对n……}
示例

1 2	dict1 = {"tom":99,"lemon":100} print(dict1) # {'tom': 99, 'lemon': 100}

二、字典操作

1. 增删改查

1.1 查看

格式：字典名[key]
注意：如果要查看的写入的键名不存在，会报错!!!
示例：

dict1 = {666:"good", "lemon":100}
print(dict1)                      # {666: 'good', 'lemon': 100}
print(dict1[666])                 # good
print(dict1["lemon"])             # 100
# print(dict1["alex"])            # 报错；因为这个key不存在

1.2 追加修改

格式：字典名[key] = value
示例：

dict2 = {"tom":60, "lemon":100}

# 追加一对key-value 'Abs': 70
dict2["Abs"] = 70
print(dict2)

# 因为一个key只能对应一个value值，所以，多次对一个key的value赋值，就是修改这个key的值
dict2["tom"] = 80
print(dict2)

1.3 pop() del() clear() 删除清空

注意：不能删除不存在的键值对

pop()：删除指定的键值对
示例

dict3 = {"tom": 80, "lemon": 100, "As": 70}

dict3.pop("As")
print(f"dict3 = {dict3}")
# dict3.pop("As")               # 报错；因为这个键值对已经不存在了

del()： 删除字典或指定的键值对
示例

dict3 = {"tom": 80, "lemon": 100, "As": 70}

# 删除指定键值对
del dict3["As"]
print(f"dict3 = {dict3}")

# 删除字典
del(dict3)

clear()：重置字典
示例

dict3 = {"tom": 80, "lemon": 100, "As": 70}

# 重置字典
print(f"dict3 = {dict3}")
dict3.clear()
print(f"dict3 = {dict3}")

2. 字典函数及遍历

2.1 函数

get()：如果key存在，返回其对应的value值，如果不存在，返回None
keys()：查找字典中所有的key；返回可迭代对象，里面的数据是列表，列表中的元素都是字典中的key名
values()：查找字典中所有的value；返回可迭代对象，里面的数据是列表，列表中的元素都是字典中key名对应的value值
items()：查找字典中所有的键值对；返回可迭代对象，里面的数据是元组，元组数据1是字典key，元组数据2是字典key对应的value值
示例

dict4 = {"tom":60,"lemon":100, "lily":79}

#1 get() 
print(dict4.get("lemon"))    # 返回的是100
print(dict4.get("alex"))     # 返回的是None

#2 keys()
print(dict4.keys())          # dict_keys(['tom', 'lemon', 'lily'])

#3 values()
print(dict4.values())        # dict_values([60, 100, 79])

#4 items()
print(dict4.items())         # dict_items([('tom', 60), ('lemon', 100), ('lily', 79)])

2.2 遍历

keys()：遍历字典中的所有key
values()：遍历字典中的value
items()：同时遍历字典中的key和value
enumerate(dict) ：生成序列号；其实这种遍历方式是没有意义的，因为字典是无序的，即使有了序列号也是不稳定的
示例

#1 keys()
dict5 = {"tom": 80, "lemon": 100, "As": 70}
for key in dict5.keys():   # key 键名
    print("key = %s" % key)


# values()
dict6 = {"tom": 100, "lemon": 70, "As": 59}
for value in dict6.values():    # value 值
    print("value = %d" % value)


# items()
dict7 = {"lemon": 100, "As": 70, "Bs": 59}
for key,value in dict7.items():
    print(f"{key} = {value}")


# enumerate(dict) 
dict8 = {"tom":60, "lemon":100, "lily":110}
for i, v2 in enumerate(dict8):
    print(i, v2)    
    # 虽然在输出的时候看起来字典是有序的，但实际上字典在内存中就是无序的，这点毋庸置疑

三、练习题

# 需求：有一个字符串，在控制台输入一个单词统计出现过多少次
# count
W = input("请输入一个单词：")
Str = "lemon is a good man lemon is a nice man lemon is a cool man lemon is a good man lemon is a noble man lemon is a good man"
print(Str.count(W))


# 字典
W = input("请输入一个单词：")
d = {}   # word:次数
Str = "lemon is a good man lemon is a nice man lemon is a cool man lemon is a good man lemon is a noble man"
t = Str.split(" ")  # 以空格为分隔符截取字符串，将字符串切割成列表
for v in t:
    c = d.get(v)
    if c == None:
        d[v] = 1
    else:
        d[v] += 1
print(d)          # 每个单词的次数
print(d[W])



'''流程
1、以空格切割字符串

2、循环处理列表中的每个元素

3、以元素当作key去一个字典中提取数据

4、如果没有提取到，就以该元素作为key，1作为value 存进字典

5、如果提取到，将对应的key的value值修改，值加1

6、根据输入的字符串当作key再去字典取值

'''

Set（集合）

一、set 概念

1. 什么是集合？

集合本质
- 类似 dict ，是一组key的集合，不储存value
- 是无序和无重复元素的集合
- 可以使用大括号 { } 或者 set() 函数创建集合
- 注意：创建空集合时就必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

2. 如何创建集合？

格式
- 集合名 = {元素1, 元素2, 元素2, ……, 元素n}
- set()
示例

# 创建空集合
set1 = set()
print(type(set1), set1)        # <class 'set'> set()

# 创建带有元素的集合
set2 = {1, 2, "lemon"}
print(type(set2), set2)        # <class 'set'> {1, 2, 'lemon'}

# 创建带有多个重复的元素，验证set能否去重
set3 = {1, 2, 2, 2, "lemon", 3, "lemon"}
print(type(set3), set3)       # <class 'set'> {1, 2, 3, 'lemon'}

二、集合操作

1. add.() 添加

示例

set4 = {1, 2, 3}
set4.add(4)
print("set4 = %s" % set4)   # set4 = {1, 2, 3, 4}
set4.add(4)                 # 可以添加重复的，但是不会有效果，因为set是无序和无重复元素的集合
print("set4 = %s" % set4)   # set4 = {1, 2, 3, 4}

set4.add("lemon")           # set的元素可以是字符串，因为字符串是不可变的
set4.add((5, 6, 7))         # set的元素可以是元组，因为元组是不可变的
print("set4 = %s" % set4)   # set4 = {1, 2, 3, 4, (5, 6, 7), 'lemon'}

2. update() 插入

update() 插入整个list、tuple、字符串，打碎插入到set
示例

set5 = {1, 2, 3, 3}

set5.update([4, 5])
set5.update((6, 7))
set5.update("abcd")

print(f"set5={set5}")    # set5={1, 2, 3, 4, 5, 6, 7, 'a', 'd', 'b', 'c'}；set是无序的！

3. remove() discard() 删除

remove() 删除指定数据；要删除的数据如果不存在则报错
discard() 删除指定数据；要删除的数据即使不存在也不报错
示例

set6 = {10, 20, 30, 40, 50, 60, 70}

# remove()
set6.remove(30)
# set6.remove(80)            # 报错；因为不存在
print("set6 = %s" % set6)    # set6 = {70, 40, 10, 50, 20, 60}

# discard()
set6.discard(40)
set6.discard(80)
print("set6 = %s" % set6)    # set6 = {70, 10, 50, 20, 60}

4. 遍历

示例

set7 = {"lemon", "set", "good"}
# 1
for i in set7:
    print(i)    # set是没有索引的！！

# 2
for index,date in enumerate(set7):
    print(index,date)   # index就是下标，但是没有意义，因为集合是无序的！！

5. 交集、并集

交集 & ( 两个集合中相同的元素组成的集合 )
并集 | ( 两个集合中所有元素组成的集合，但是都不重复 )

set8 = set([1, 2, 3])
set9 = set([2, 3, 4])

# 交集 
a1 = set8 & set9
print("a1 = %s" % a1, type(a1))       # a1 = {2, 3} <class 'set'>

# 并集
a2 =set8 | set9
print("a2 = %s" % a2, type(a2))       # a2 = {1, 2, 3, 4} <class 'set'>

6. 类型转换

公式：想转什么类型就写什么类型
示例

# tuple --> set
Tuple1 = (1, 2, 3, 4, 5, 5, 3, 1)
Set1 = set(Tuple1)
print(Set1, type(Set1))              # {1, 2, 3, 4, 5} <class 'set'>

# set --> tuple
Set2 = {1, 2, 3, 4, 5}
Tuple2 = tuple(Set2)
print(Tuple2, type(Tuple2))          # (1, 2, 3, 4, 5) <class 'tuple'>

# list --> set
List = [1, 2, 3, 4, 5, 5, 3, 1]
print(set(List), type(set(List)))    # {1, 2, 3, 4, 5} <class 'set'>

# set --> list
Set = {1, 2, 3, 4, 5}
print(list(Set), type(list(Set)))    # [1, 2, 3, 4, 5] <class 'list'>

Python 数据类型

内置数据类型

Boolean（布尔值）

Number（数字）

int（整型）

float（浮点型）

complex（复数）

String（字符串）

一、String 概念

1. 什么是字符串？

2. 如何创建字符串？

二、string 方法

1. 字符串运算

2. 字符串的截取

3. 判断数据元素是否存在

4. 判断系列方法

5. 格式化输出 与 转义字符

6. eavl(“str”)

7. len(“str”)

8. count(str_name,[start],[and])

9. lower()

10. upper()

11. swapcase()

12. capitalize()

13. title()

14. center(width, fillchar)

15. ljust(width, fillchar)

16. rjust(width, fillchar)

17. zfill(width)

18. find(name,[start],[and])

19. rfind(name,[start],[end])

20. index(“str”, start=0, end=len(str))

21. rindex(str, start=0, end=len(str))

22. lstrip()

23. rstrip()

24. strip()

25. split(str=””,num)

26. splitlines([keepends])

27. join()

28. max() min()

29. replace(oldstr, newstr, count)

30. maketrans(“str1”, “str2”) translate(identifier)

List 列表

一、List概念

1. 什么是列表？

2. 如何创建列表？

二、列表元素的访问

1. 取值

2. 替换

三、列表操作

1. 列表组合

2. 列表重复

3.判断元素是否在列表中

4. 列表截取

5. 二维列表

四、列表方法

1. append()

2. extend()

3. insert()

4. pop()

5. remove()

6. clear()

7. index()

8. count()

9. len()

10. max() min()

11. reverse() 倒序

12. sort 排序 升序

13. 拷贝

14. list 去重复

15. 将元组转成列表

五、列表的遍历

Tuple（元组）

一、Tuple概念

1. 什么是元组

2. 如何创建元组？

二、元组的操作

1. 取值

2. 修改

3. 删除元组

5. 格式化输出与转义字符

12. sort 排序升序

1.2 追加修改

1.3 pop() del() clear() 删除清空

2. 字典函数及遍历

2. 如何创建集合？