[Python知识库]python之路-变量和基本数据类型详解（注释、变量、基本数据类型[Number、String、List、Tuple、Dict]]）

列表、元组x-mind思维导图

字符串、字典、集合和多维列表x-mind思维导图

一、注释

注释的作用：

• 增加程序的可读性

• 作为调试用

• 提高团队的合作效率

注释的分类：

• 单行注释

以井号（#）开头，右边的所有内容当做说明

• 多行注释

以三对单引号（’’’注释内容’’’）将注释包含起来

其他语法

Python的语法比较简单，采用缩进的方式。

其他语法：

• Python的语法比较简单，采用缩进的方式。

# print absolute value of an integer:
a = 100
if a >= 0:    
    print(a)
else:    
    print(-a)

上面代码中，以‘# ’是注释的标识符，可以记录当前代码所代表的意义，解释器会自动忽略这部分内容。
当语句以‘：’结尾时，缩进语句视为代码块。

在Python中，通常我们以4个空格的缩进来进行区分。可以在每句结束之后加一个‘;’号。通常在Python中，默认以换行为新的一行，若想在一行输入多句语句，一定要加‘;’，否则报错。

注意： 由于Python采用缩进的语法，在你复制，粘贴语句时，一定要注意，重新检查当前代码的缩进格式。 在Python中，对大小写十分敏感，如果大小写错误，会报错。< /font>

二、变量

标识符

什么是标识符
　　标识符是自己定义的,如变量名 、函数名等

标识符命名规则

1、只能包含字母、数字和下划线。变量名可以以字母或者下划线开头。但是不能以数字开头。

2、不能包含空格，但可以使用下划线来分隔其中的单词。

3、不能使用Python中的关键字作为变量名

4、建议使用驼峰命名法，驼峰式命名分为大驼峰（UserName）。和小驼峰（userName）。

常用关键字

系统有一些常用关键字不可以用来当做标识符。
　
在python中查看：

import keyword

print(keyword.kwlist)

[‘False’, ‘None’, ‘True’, ‘and’, ‘as’, ‘assert’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’,
‘lambda’, ‘nonlocal’, ‘not’, ‘or’, ‘pass’, ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, ‘yield’]

三、数据类型

Number

int:

Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样。

float:

浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的。

complex:

一个实数和一个虚数的组合构成一个复数。

bool:

bool值是特殊的整型，取值范围只有两个值，也就是True和False。

字符串

字符串就是一系列任意文本。Python中的字符串用单引号或者双引号括起来，同时可以使用反斜杠（\）转义特殊字符。

单引号（’’）和双引号（"”）本身只是一种表示方式，不是字符串的一部分，因此，字符串’hello’只有h,e,l,l,o这五个字符。如果’本身也是字符的话，那么就可以用””括起来，比如”I’m OK” 当中包含了一个 ’ 。如果字符串内部包含 ’ 或者 ” ，但是又想当成普通字符串处理怎么办？这个时候就要用转义字符（\）来标识。

操作字符串

截取字符串语法：变量[开始下标：结束下标]

加号（+）是字符串的连接符

星号（*）表示复制当前字符串

格式化输入

通过它能够完成从键盘获取数据，然后保存到指定的变量中 input获取的数据，都以字符串的方式进行保存，即使输入的是数字，那么也是以字符串方式保存
　　
字符串下标与切片

下标就是编号,字符串实际是字符的组合。

声明一个字符串str1值为：abcd
　　

字符串切片

• 切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

• 切片的语法：[起始:结束:步长]

  • 包含开始索引
  • 不包含结束索引
  • 省略开始索引,默认从0开始
  • 省略结束索引,默认到最后
  • 省略步长,默认步长为1

str1 = "abcdefg"
str2 = str1[2:4:1]
print(str2)
str2 = str1[:4:1]
print(str2)
str2 = str1[2::1]
print(str2)
str2 = str1[2:4:]
print(str2)

列表切片

list1 = ["刘备", "关羽", "张飞", "赵云", "马超"]
list2 = list1[2:4:]
print(list2)
list2 = list1[::2]
print(list2)

字符串切片案例

str1 = "我爱python"
str2 = str1[2:6]
print(str2)

str2 = str1[2:]
print(str2)

str2 = str1[:6]
print(str2)

str2 = str1[:]
print(str2)

str2 = str1[::2]
print(str2)

str2 = str1[1::2]
print(str2)

str2 = str1[2:-1]
print(str2)

str2 = str1[-2:]
print(str2)

str2 = str1[::-1]
print(str2)

课堂练习-列表以及成员都逆置

# ['刘备', '诸葛亮', '曹操', '周瑜', '关羽']
# 作业,把列表中个成员名字逆序
# 把列表中也逆序
list1 = ['刘备', '诸葛亮', '曹操', '周瑜', '关羽']
list1 = list1[::-1]   # 把列表中的成员逆置
# print(list1)
# 列表中每个字符串也要逆置
# 思路,遍历列表,在遍历出来每个字符串后,把每个字符串逆置
index = 0   # 定义了一个变量叫index,值为0
for n in list1:
    str1 = n[::-1]  # str1就是n颠倒后的结果
    list1[index] = str1  
    # 第一次循环的时候index的值为0,所以相当于list1[0] = str1
    # 第二次循环的时候index的值为1,所以相当于list1[1] = str1
    index += 1
print(list1)

索引为一个变量的用例

• 列表,或者元组,或者字符串都经常用[索引]的方式访问成员
• [索引]可以是一个具体的数字,也可以是一个变量

a = 1
列表[a] = '张三'   # 相当于列表[1] = '张三'

list1 = ['刘备', '关羽', '张飞']
list1[0] = '曹操'
print(list1)

list1[1] = '周瑜'
print(list1)
index = 2
list1[index] = '马超'
print(list1)
# 列表[索引] = 值 修改列表指定成员的值
# 索引可以是一个具体的数字,也可以是一个变量
index = 0
list1[index] = '张三'
print(list1)

字符串常用函数




字符串练习：

# -*- coding:utf-8 -*-
 
'''
    格式化输出
'''
 
# name = 'joe'
# age = 18
# address = '上海'
# print('大家好我叫%s，我今年%d岁，我来自%s'%(name,age,address))
# print('大家好我叫%s'%name)
 
'''
    字符串常用函数
'''
#find
# str = 'I love python'
# print(str.find('o'))#返回的是该字符的位置
# print(str.find('w')) #没有的化返回-1
 
#index
# str = 'I love python'
# print(str.index'o'))#返回的是该字符的位置
# print(str.index('o')) #没有的化返回报错信息
 
#count
# str = 'I love python'
# print(str.count('o'))#返回的是该字符出现的次数
# print(str.count('o',2,6)) #在指定位置查找出现的次数
 
#replace
# str = 'I love python'
# print(str.replace('p','P'))#替换并输出  I love Python
 
 
#split
# str = 'I love python o'
# print(str.split(' '))#指定字符切分 ['I', 'love', 'python', 'o']
#capitalize
# str = 'i love python o'
# print(str.capitalize()) #将字符串的首字母大写I love python o
 
#capitalize
# str = 'i love python o'
# print(str.title()) #将字符串中每个单词的的首字母大写I Love Python O
 
#startswith
# str = 'i love python o'
# print(str.startswith('i')) #检测字符串是否以指定的字符开头 是则返回True 否则False
 
#swith
# str = 'i love python o'
# print(str.endswith('p')) #检测字符串是否以指定的字符结尾 是则返回True 否则False
 
#upper
# str = 'i love python o'
# print(str.upper()) #所有字母转化为大写
 
#lower
# str = 'I LOVE PYTHON O'
# print(str.lower()) #字符串转化为小写
 
#str1 = "AbCdEf"
#str2 = str1.swapcase()
#print(str2)

#ljust
# str = 'hello'
# print(str.ljust(10)) #返回一个原字符串左对齐，并使用空格填充至长度width的新字符串hello
 
 
#rjust
# str = 'hello'
# print(str.rjust(10)) #返回一个原字符串右对齐，并使用空格填充至长度width的新字符串     hello
 
#center
# str = 'hello'
# print(str.center(10)) #返回一个原字符串居中，并使用空格填充至长度width的新字符串  hello
 
#lstrip
# str = '   hello'
# print(str.lstrip()) #除去字符串左边的空白字符hello
 
#rstrip
# str = 'hello   '
# print(str.rstrip()) #除去字符串右边的空白字符hello
 
#partition
# str = 'hello world hello china'
# print(str.partition('world')) #可以将字符串以str进行分割成三部分 str前，str,str后('hello ', 'world', ' hello china')
 
#join
# str = 'hello world hello china'
# str1 = '-'
# print(str1.join(str)) #str中每个字符后面插入str1,构造出新的字符串h-e-l-l-o- -w-o-r-l-d- -h-e-l-l-o- -c-h-i-n-a
 
#isspace
# str = 'hello world hello china'
# print(str.isspace()) #如果str中只包含空格，则返回true 否则返回false
 
#isalnum
# str = 'hello'
# print(str.isalnum()) #如果str中所有字符都是字母或者数字，则返回true 否则返回false
 
#isdigit
# str = '8765'
# print(str.isdigit()) #如果str中只包含数字，则返回true 否则返回false
 
#isalpha
str = 'hello china'
print(str.isalpha()) #如果str中所有字符都是字母，则返回true 否则返回false

# 课堂练习-字符串中所有数字求和
str1 = "123 98 234 23 345"
# 思路,先把str1中每个数字分隔出来
list1 = str1.split(" ")
# 遍历列表,计算和
sum = 0
for n in list1:
    sum += int(n)    # n的类型为字符串,所以需要转化为int
print(sum)

# 去除字符串中间空格
str1 = "aaa   bbbbb     eeee     aaaaaa   bbbb"
str2 = str1.replace(" ", "")
print(str2)

# 格式化字符串
- %x意思是把一个十进制数按照十六进制方式显示,abcdef用小写表示
- %X意思是把一个十进制数按照十六进制方式显示,ABCDEF用大写表示
print("%x" % 9)
print("%x" % 10)  # 十进制的10就是十六进制的a
print("%x" % 16)  # 十进制的16就是十六进制的???
print("%x" % 15)  # 十进制的15就是十六进制的???
# 0 1 2 3 4 5 6 7 8 9 a b c d e f 10 11 12 13 ...
print("%X" % 10)

列表

列表写在[ ]内，元素之间用逗号隔开：

注意：

List写在方括号之间，元素用逗号隔开

和字符串一样，List可以被索引和切片

List可以使用加号（+）操作进行拼接

List中的元素是可以被改变的

列表的访问：

列表是由一系列按特定顺序排列的元素组成，列表能存储多种类型的数据，其中的元素之间可以没有任何关系
列表索引

列表的操作：

修改列表元素:

修改列表元素的语法和访问列表元素的语法类似，指定列表名和要修改元素的索引，再指定新值

以下列表名为：students，需要将jack修改为tom
　　

添加列表元素1：

在列表末尾追加元素：使用append()方法将元素追加到列表的末尾。也可以用append()方法来动态创建列表

以下列表名为：students，需要将‘篮球添加到列表的末尾’，使用append()方法
　　

添加列表元素2：

在列表中插入元素：通过指定新元素的索引和值，使用insert()方法可以在列表的任何位置添加新元素

以下列表名为：students，需要将‘音乐插入到男的后面，使用insert()方法
　　

删除列表元素

使用pop()方法删除元素：pop方法用于移出列表中的一个元素（默认是最后一个元素），可以指定元素索引，并且返回该元素的值。

使用del语句删除元素：如果知道要删除的元素在列表中的位置，可使用del语句删除元素，元素一旦被删除之后就再无法访问

使用remove()方法删除元素：当不知道元素索引，只知道元素值的时候，使用remove()方法删除元素

查找列表元素

所谓的查找，就是看看指定的元素是否存在

in（存在）,如果存在那么结果为true，否则为false

not in（不存在），如果不存在那么结果为true，否则false

列表推导式

拆包

Python列表函数(公共方法)
　

多维列表

• 一个列表的成员,又是一个列表,这种列表就是多维列表

list1 = ['张飞', '刘备', '关羽']
# list1是一个一维的列表,有三个成员,分别为'张飞', '刘备', '关羽'三个字符串
list2 = [['张飞', '刘备', '关羽'], ['曹操', '周瑜', '孙权']]
# list2是一个二维列表,有两个成员
# 第一个成员也是一个列表['张飞', '刘备', '关羽']
# 第二个成员也是一个列表['曹操', '周瑜', '孙权']
a = list2[1]  # a是什么, a是一个列表['曹操', '周瑜', '孙权']
print(a)
print(a[1])  # 显示列表a的第二个成员

列表练习：

# -*- coding:utf-8 -*-
 
#列表：是由一系列特定顺序排列的元素组成
      # 列表可以存储多种类型的数据，
      # 元素之间没有任何关系
 
'''
    访问列表
'''
 
# list01 = ['jack','jane','joe','black','']
# print(list01[2])  #通过下标访问
 
#二维列表
# list02 = ['jack','jane',['leonado','joe'],'black','']
# print(list02[2])
# print(list02[2][0]) #获取leonado
 
# list02 = ['jack','jane',['leonado','joe'],'black','']
# list02[0] = 'lili'   #通过下标获取到元素，并且给其赋新的值
# list02[2][0] = 'susan'
# print(list02)
 
#列表是一个可变的类型数据，允许我们对其里面的数据进行修改(增、删、改操作)
 
'''
    列表的操作-追加
       append列表末尾追加
       insert指定位置插入
'''
 
#append
# list02 = ['jack','jane','joe']
# list02.append('susam')
# print(list02)
 
#insert
# list02 = ['jack','jane','joe','black']
# print('插入之前')
# print(list02)
# print('_'*20)
# #指定位置插入
# list02.insert(1,'susan')
# print(list02)
 
'''
    删除元素
       pop默认从最后删除,还可以通过指定索引删除
       del通过指定位置删除
       remove通过值删除
# '''
# list02 = ['jack','jane','joe','black']
# print('删除之前')
# print(list02)
# print('_'*20)
# print(list02.pop())  #执行删除操作  并且返回删除的元素
# print(list02)
# print('继续删除')
# print('_'*20)
# print(list02.pop(1))  #执行删除操作  并且返回删除的元素
# print(list02)
#del
# list02 = ['jack','jane','joe','black']
# print('删除之前')
# print(list02)
# print('_'*20)
# del list02[1] #指定索引删除  彻底删除
# del list02  #默认将整个列表 从内存中彻底删除，
# print(list02)
 
#remove 在不知道下标，但是知道具体值的时候通过值来删除
# list02 = ['jack','jane','joe','black']
# print('删除之前')
# print(list02)
# print('_'*20)
# list02.remove('jane') #通过元素的值进行删除
# print(list02)
 
'''
  查找元素是否存在 
  in
  not in
'''
# list02 = ['jack','jane','joe','black']
# name = 'jack'
# name2 = 'lee'
# print(name in list02)
# print(name2 in list02)
 
# list02 = ['jack','jane','joe','black']
# name = 'jack'
# name2 = 'lee'
# print(name not in list02)
# print(name2 not in list02)

# -*- coding:utf-8 -*-
 
'''
    列表函数
'''
 
# list05 = ['jack','jane','joe','black','12']
# #查看列表长度 返回列表元素个数
# print(len(list05)) #类似于一个方法，将参数传入
 
# list05 = ['jack','jane','joe','black'] #如果是字符类型，取字母靠后的
# list05 = [1,52,23,58,100] #默认数值输出结果，取最大值。
# print(max(list05)) #类似于一个方法，将参数传入
 
 
# list05 = ['jack','jane','joe','black'] #如果是字符类型，取字母靠迁的
# list05 = [1,52,23,58,100] #默认数值输出结果，取最小值。
# print(min(list05)) #类似于一个方法，将参数传入
 
# list05 = ['jack','jane','joe','black','joe','jane']
# print(list05.count('joe')) #统计元素出现的次数
 
 
# list05 = ['jack','jane','joe','black']
# list06 = ['aaa','bc']
# list05.extend(list06) #扩展列表 在一个列表末尾一次性追加一个新列表 传入参数为一个列表 类似于单个元素使用append追加
# print(list05.extend(list06)) #必须先追加再输出
# print(list05)
 
 
# list05 = ['jack', 'jane', 'joe', 'black','joe']
# print(list05.index('joe')) #从一个列表中找出某一个值第一次出现的位置的索引
 
# list05 = ['jack', 'jane', 'joe', 'black','joe']
# list05.reverse() #对列表中的元素做反向旋转
# print(list05)
# print(list05.reverse()) #不可以在输出里面做旋转，必须先反向旋转再单独输出  和追加extend一样
 
# list06 = [2,3,5,9,6,12,40]
# list06.sort()  #对列表进行排序
# 'print(list06.sort()) #先做排序  在输出
# print(list06)
 
# list05 = ['jack', 'jane', 'joe', 'black','joe']
# list05.clear() #用于清空列表
# print(list05)
 
# list05 = ['jack', 'jane', 'joe', 'black','joe']
# list07 = list05.copy() #复制列表
# print(list07)
 
#
# list = ['lee','jone','jack']
# list.insert(0,'teacher')
# list.insert(list.__len__(),'bzr')
# print(list)
# # print(list.__len__())
# print(list[1][3])

元组

• Tuple（元组）与列表类似，不同之处在于元组的元素不能修改
• 元组用（）定义；

# 定义一个元组tuple2，有三个元素
tuple2 = ('孙权', 28, 2.75)
# 定义一个空元组
tuple3 = ()

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

# 元组中只包含一个元素时，需要在元素后面加逗号
tuple4 = (50, )

• 定义元组时，（）可以省略

# 定义元组时，（）可以省略
tuple5 = '张飞', 30
tuple6 = '吕布',

• 元组只有一个元素，尝试后面添加和不添加逗号的区别

# 元组只有一个元素，尝试后面添加和不添加逗号的区别
a = ("hello", )
a = ("hello")

元组常用方法

元组的常用方法与列表类似，元组的内容不可修改，所以没有增加、删除和修改的相关方法。

循环遍历元组

与遍历一个列表类似

元组与列表之间的转换

• 把列表转换为元组目的是让列表不可以被修改，保证数据的安全
• 使用list函数可以把元组转换为列表
• 使用tuple函数可以把列表转换为元组

list7 = ['刘备', '关羽', '张飞']
# 通过tuple函数把list7转换为元组
tuple7 = tuple(list7)

tuple8 = ('孙权', '周瑜', '鲁肃')
# 通过list函数把tuple8转换为列表
list8 = list(tuple8)

• 将元组tuple8追加至list8的后面

# 将元组tuple8追加至list8的后面
list7.extend(tuple8)
print(list7)

集合

集合定义

• 定义集合用{}
• 定义空集合用set()
• 集合与列表的区别
  • 集合中所有成员是无序的,列表中所有成员是有序的
  • 集合中成员的值不能重复,列表中成员的值可以重复

set1 = {'刘备', '关羽', '张飞'} # 定义了一个集合变量set1
set2 = set()   # 定义一个空集合set2
set3 = {'刘备', '关羽', '刘备'}
print(set1)
print(set2)
print(set3)

集合常用操作

• add添加值
  • 集合变量.add(值)
• pop删除一个值
  • 集合变量.pop()
• remove删除指定的值
  • 集合变量.remove(值)
• clear删除所有值
  • 集合变量.clear()

set1 = {'刘备', '关羽', '张飞'} # 定义了一个集合变量set1
set2 = set()   # 定义一个空集合set2
set3 = {'刘备', '关羽', '刘备'}
print(set1)
print(set2)
print(set3)

set1.add('曹操')
print(set1)
# set1.pop()
print(set1)
set1.remove('刘备')
print(set1)
set1.clear()
print(set1)

set1 = set()
a = 0
while a < 5:
    set1.add(int(input("请输入一个整数")))
    a += 1
print(min(set1))

循环遍历集合

• 语法

for n in 集合变量:
    循环中的代码

set1 = {'刘备', '关羽', '张飞'}
for n in set1:
    print(n)
# 这个for循环3次
# 第一次循环的时候n是刘备或者...
# 第二次循环的时候n是...
# 第三次循环的时候n是...
# 不管顺序是否对,但遍历的结果,总是能把集合中每个成员都显示出来

set1 = set()
a = 0
while a < 3:
    set1.add(input("请输入字符串"))
    a += 1

for n in set1:
    print(n)

字典

字典的定义

• 用{}定义
• 用{}定义一个空字典
• 一个字典中可以存放多个键值对
  • 键key,一个字典中键不能重复
  • 值value
  • 键和值用冒号分隔
• 字典和集合的区别
  • 集合里面只有值
  • 字典里面是键值对

dict1 = {"name":"刘备", "age":20, "sex":"男"}
dict2 = {}  # 定义了一个空字典

新增或者修改键值对

• 字典[键] = 值
  • 如果键存在,就是修改值
  • 如果键不存在,就是新增键值对

dict1 = {"name":"刘备", "age":20, "sex":"男"}
dict1["name"] = "关羽"  # 修改键name对应的值
print(dict1)
dict1["class"] = '1班'   # 新增一个键值对,键为class,值为1班
print(dict1)

删除键值对

• pop(键)

dict1.pop('name')   # 删除name键,一旦键被删除,对应的值也同时被删除

清空

• clear()

dict1.clear()

得到键对应的值

• 变量名 = 字典[键]
  • 把键对应的值赋值给指定的变量

a = dict1["age"]  # 得到键对应的值

dict1 = {"name":"刘备", "age":20, "sex":"男"}
dict1["name"] = "关羽"  # 修改键name对应的值
print(dict1)
dict1["class"] = '1班'   # 新增一个键值对,键为class,值为1班
print(dict1)
dict1.pop('name')   # 删除name键,一旦键被删除,对应的值也同时被删除
print(dict1)
# dict1.clear()
print(dict1)
a = dict1["age"]  # 得到键对应的值
print(a)
b = dict1["sex"]  # 得到键sex对应的值
print(b)

dict1 = {"name":"周瑜", "age":32, "id":"001"}
dict1["sex"] = "男"
dict1.pop("id")
dict1["age"] = 26
print(dict1)

遍历字典

• 语法

for n in 字典:
    代码
# n是键

dict1 = {"name":"刘备", "age":20, "sex":"男"}
for n in dict1:
    print(n, dict1[n])   # dict1[n]意思就是得到键n对应的值
    #直接写n代表输出键,dict1[n]代表输出键对应的值

# for循环3次
# n代表键,第一次循环n的值是name,第二次循环n是age,第三次循环n是sex
# 如何在for循环中输出值?

通过items遍历字典

• 字典.items()返回一个包含键和值的元组

dict1 = {"name":"刘备", "age":20, "sex":"男"}
# for n in dict1.items():
#     print(n)
# 一旦使用了字典的items方法,n就是一个包含了键和值的元组
# n就是一个包含了两个成员的元组,第一个成员是键,第二个成员是值
# for循环了3次
# 第一次n = ('name', '刘备')
# 第二次n = ('age', 20)
# 第三次n = ('sex', '男')

# for n in dict1.items():
#     a, b = n  # 对一个元组进行拆包
#     print(a, b)

for a, b in dict1.items():  # a就是键,b就是键对应的值
    print(a, b)

dict1 = {"a":23, "b":4, "c":9, "d":3, "e":12}
for n in dict1:
    print(n, dict1[n])
print("------------------")
for a, b in dict1.items():
    print(a, b)

练习-显示值9对应的键名

dict1 = {"a":23, "b":4, "c":9, "d":3, "e":12}
# 思路
# 遍历字典,在遍历的时候,检查值是否为9,如果是9,显示9对应的键
for n in dict1:
    if dict1[n] == 9:
        print(n)  # 如果条件成立,那么就显示n,就是是值9对应的键