目录

一、数据类型

1.1变量与常量

1.1.1变量

 1.1.2常量

1.2字符串类型

1.3整数与浮点数

1.4List列表

1.5 元组tuple

1.6字典dict

二、字符串格式化

三、数据输入和类型转换

 四、简单列表习题练习

---

一、数据类型

变量类型：

整数int（4字节，会自动扩容）、浮点数float（8字节）、布尔类型bool（一个字节）、字符串（变长）可使用len求长度、其他

空值：None，不是布尔类型，而是NoneType。

1.1变量与常量

变量：在程序运行过程中，值会发生变化的量

常量：在程序运行过程中，值不会发生变化的量

无论是变量还是常量，创建时都会在内存中开辟一块空间，用于保存它的值。

• 动态语言类型：程序运行中，变量类型会发生改变（修改变量）
• 静态语言类型：程序运行过程中，变量类型始终不发生变化，如C++/java
• 二者的判断关键：运行中，变量类型是否发生变化

Python 中，由于python的动态语言特性，故变量和常量都不需事先声明类型:(age=18)

静态语言：C++、Java、Golang,需要事先声明类型:（int age,string name）

1.1.1变量

变量可以指定不同的数据类型，从而决定其在内存中的位置（由解释器根据数据类型分配）。

（1）赋值“=”和比较“==”

首次使用 = 相当于对变量进行赋值（初始化），后续再对变量使用 = 相当于修改变量的内容。

age = 18  #赋值
age == 18  #比较，判断age是否为18，返回值True/Falsecounter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串

（2）变量在使用前必须赋值，才会被创建，若不赋值，则抛出未定义的异常。

 （3）赋值方式：单个、多个、先计算后赋值、分别赋值

age = 18  #单个赋值
a = b = c = 2   #多个赋值
d = 17+2  #先计算后赋值
a, b, c = 1,2,3   #分别赋值

（4） 变量赋值的含义 

name = "python"

1.内存中创建了一个字符串对象"python"

2.内存中创建一个变量name，并将其指向"python"

3.把一个变量a赋值给另一个变量b，意味着将变量b指向变量a所指向的数据

4.若继续对a赋值，a内存地址会改变，而b不会改变。Python中的一切都是对象，变量是对象的引用！ 

• 执行a = ‘Jack’，解释器创建字符串‘Jack’对象和变量a，并把a指向‘Jack’对象；

• 执行b = a,解释器创建变量b，并且将其指向变量a指向的字符串‘Jack’对象；

• 执行a = ‘python’,解释器创建字符串‘Tom’对象，并把a改为指向‘Tom’对象，与b无关

 

a = "Jack"
b = a  #a赋值给b ，创建变量b
print(b)   #输出"Jack"
id(a) == id(b)  #输出true    id()可查看内存地址  a = "python"   #a的内存地址发生改变
id(a) == id(b)  #输出false   

 1.1.2常量

常量（不变的量），python中全部大写的变量名即为常量

常量常放于代码最上端，做全局使用

PI = 3.1415926  #常量圆周率

---

1.2字符串类型

 字符串或串(String)是由数字、字母、下划线组成的一串字符。

若有字符串嵌套，内外分别用单双区分就行了：（三引号使用同上，三者关系等效），常使用三引号创建多行字符串

b = "'hello' python!!!"
c =  'hello "python"'
print(b,c)name_1 = 'Jack'  # 单引号
name_2 = "Jack"  # 双引号
name_3 =  '''Jack''' # 三个单引号
name_4 = """Jack"""  # 三个双引号
name_1 == name_2 == name_3 == name_4

（1）python的字串列表有2种取值顺序:

• 从左到右索引默认0开始的，最大范围是字符串长度少1
• 从右到左索引默认-1开始的，最大范围是字符串开头

（2）字符串截取

 截取字符串字串 [头下标：尾下标 ]   前闭后开

加号（+）是字符串连接运算符(拼接功能，不同数据类型不能进行拼接)，星号（*）是重复操作

str = 'Hello World!' 
print str           # 输出完整字符串H
print str[0]        # 输出字符串中的第一个字符 H
print str[2:5]      # 输出字符串中第三个至第六个之间的字符串 llo
print str[2:]       # 输出从第三个字符开始的字符串 llo world!
print str * 2       # 输出字符串两次  Hello World!Hello World!
print str + "TEST"  # 输出连接的字符串Hello World!TEST

列表截取可以接收第三个参数，参数作用是截取的步长 [ 1: 4 :2 ] 步长为2

（3）常用方法

msg = "       python编程       "

1）去除首尾空格：

msg.lstrip()  # 去除左边空格
msg.rstrip()  # 去除右边空格
msg.strip()   # 去除左右两边空格

2）判断字符串是否以某字符串开头startswith/结尾endswith

msg = "Hello, Python"
msg.startswith("Hello")   #True
msg.startswith("hello")   #False

3)格式化字符串

name = input()  #输入字符串表示名字print(f'I am {name} and I am studying Python in Nowcoder!')  
print('I am %s and I am studying Python in Nowcoder!'%name)

4)字符串分割  （多个字符串分隔为字符串列表）

languages = "Python,Java,Golang"
languages.split(",")    #['Python', 'Java', 'Golang']

1.3整数与浮点数

Python 支持的数字类型有三种：整数、浮点数和复数。

(1）整数int：

是正或负整数，不带小数点。

表示数字的时候，还可用八进制或十六进制来表示：

• 十六进制：用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2。

• 八进制：用0o前缀和0-7表示，例如0o12

a = 0x0001 # 十六进制 1
b = 0o01  # 八进制  1

(2)常用方法

四舍五入:如round（3.14）=3，round(3.81) = 4

取余：a // b

取整：int(3.14) = 3

1.4List列表

列表和原则的区别：

元组不可变：只能读元素，不可修改

列表可变：可读可写

List（用 [ ] 标识）是Python 中使用最频繁的数据类型。是 python 最通用的复合数据类型。可以完成大多数集合类的数据结构实现，支持字符，数字，字符串甚至可以包含列表（即嵌套）。下标可以为空表示取到头或尾。

1）创建列表：两种方式即可

python中不限制列表中元素的类型（元素可存放任意类型）

a = []  #空列表
b = list()
print(type(a))  #<class 'list'>
print(type(b))  #<class 'list'>

2） 访问下标

注意防止下标越界。

打印列表最后一个元素：-1指的是最后一个元素（长度-1）

print(list[len(list)-1])  #打印列表list最后一个元素
print(list[-1])    #打印列表list最后一个元素

3）切片操作

取出列表中下标连续的一组元素，也相当于得到一个子列表（下标范围前闭后开）

除了获取某个确定下标的元素外，切片操作得到的是列表形式的数据

list = ['runoob', 786 , 2.23, 'john', 70.2]
tinylist = [123, 'john']print(list)               # 输出完整列表  ['runoob', 786 , 2.23, 'john', 70.2]
print(list[0])            # 输出列表的第一个元素   runoob
print(list[:-1])          #从前往后取数据，不包括最后一个元素
print(list[:])            #得到列表自身所有数据
print(list[1:3])          # 输出第二个至第三个元素  [786 , 2.23] 
print(list[2:])           # 输出从第三个开始至列表末尾的所有元素   [2.23, 'john', 70.2]
print(tinylist * 2)       # 输出列表两次 [123, 'john', 123, 'john']
print(list + tinylist)    # 打印组合的列表  ['runoob', 786 , 2.23, 'john', 70.2,123, 'john']

切片操作，可以指定步长（步长为负数时，从后往前取数据）：

list = [1,2,3,4,5,6,7,8]
print(list[::1])  #1是指定的步长   [1, 2, 3, 4, 5, 6, 7, 8]
print(list[1:7:2])  #2 是指定的步长    [2, 4, 6]print(list[::-2])  #2 是指定的步长  [8, 6, 4, 2]
print(list[::-1])  #2 是指定的步长  [8, 7, 6, 5, 4, 3, 2, 1]

4）列表的遍历

取出列表中的每个元素，并进行某种操作

list = [1,2,3,4,5,6,7,8,9]
#方法一：
for elem in list:print(elem)elem = elem + 10  #不修改变量本身，只修改临时变量print(elem)#方法2：
for i in range(0,len(list)):print(list[i])list[i] = list[i]+10  #可修改每一个列表元素    
print(list)  #输出新的list#方法3：使用while循环，通过下标遍历
i = 0
while 1 < len(list):print(list[i])i += 1

5）列表的插入

list列表可插入不同数据类型的元素，且append函数是搭配列表对象一起使用的。需要搭配对象使用的函数也叫“方法”

list = [1,2,3,4,5]
list.append(0)
list.append('hello')
print(list)   #[1, 2, 3, 4, 5, 0, 'hello']

insert插入方法（指定下标处插入元素）：

list = [1,2,3,4,5]
list.insert(0,'python')
list.insert(2,'hello')print(list)  #['python', 1, 'hello', 2, 3, 4, 5]

6)列表的查找

注意！！！索引不能超出列表长度

list = [1,2,3,4,5]
print(len(list))   #求列表长度：5
print(5 in list)   #判断某个元素5是否存在于列表里
print(list.index(5))  #使用index获取元素5在列表中的位置
print(list.count(5))   #统计元素5出现的次数

7）列表的删除

• pop（）：删除末尾元素
• pop（i）：删除i下标的元素
• remove（num）： 删除列表中的num元素

删除末位几个数据，连续几次pop操作即可

list = [1,2,3,4,5] 
list.pop()  #删除末尾元素  #[1, 2, 3, 4]
list.pop(2)  #删除下标为2的元素   [1, 2, 4]
list.remove(4)   #[1, 2]
print(list)      #[1, 2]company = input().split()
companylist = []
for i in company:companylist.append(i)#方法一
companylist.pop(0)  #删除第一个元素
print(companylist)
#方法二
companylist.remove(companylist[0])
print(companylist)

给定两个字符串A和·B，删除A字符串中的B字符串：

friend = input().split()
argfriend = input()friendlist = []
for i in friend:friendlist.append(i)
friendlist.remove(argfriend)
print(friendlist)

8）列表的反转reverse和排序：

注意！！列表反转reverse()和排序sort()不能直接和print放一起使用（如：print(num.sort())写法错误），分开两行才行，如下代码：

list = [1,9,7,100,2,3,4,5]
list.reverse()
print(list)    # [5, 4, 3, 2, 100, 7, 9, 1]
list.sort()
print(list)    #  [1, 2, 3, 4, 5, 7, 9, 100]

9）列表的拼接： 列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

• 使用 + 拼接两个列表，不改变原列表
• 使用extend拼接(不需要变量会接收，没有返回值)，相比“+”拼接更高效（把后一个列表拼接到前一个列表里），会改变原列表a的内容（拼接后是存储到新的变量a里，同时也会释放旧的变量a）

a = [1,2,3]
b = [6,7,8]
print(a + b)   #[1, 2, 3, 6, 7, 8]  # c = a.extend(b)   # 返回None,extend拼接不需要返回值
a.extend(b)   #把b拼接到a列表里
print(a)   #[1, 2, 3, 6, 7, 8]
print(b)   #[6, 7, 8]

1.5 元组tuple

元组不可变对象，相当于只读列表（不能修改），但是可以哈希

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

元组中的元素值不允许删除，但可使用del语句来删除整个元组：del tup

元组之间可以使用 + 号和 * 号进行运算。可以组合和复制，运算后会生成一个新的元组。

1）创建元组：

元组（用 () 标识），元素可为任意类型。

a = ()  #创建一个空元组
b = tuple()  #创建一个空元组
print(type(a))
print(type(b))c = (1,2,'python',[1,2,3],[],True)
print(c)     #(1, 2, 'python', [1, 2, 3], [], True)
print(type(c))   #<class 'tuple'>

2）元组访问：通过下标获取特定元素或者切片获取元组的某一部分

注意不能数组越界

c = (1,2,'python',[1,2,3],[],True)
print(c[1])  #2
print(c[-1])   #True
print(c[0:4])   #(1, 2, 'python', [1, 2, 3])#for循环遍历：
for elem in c:print(elem)#判定元素是否存在：print(2 in c)  #判断元素2是否存在元组中print(c.index(2))  #打印输出下标为2的元素

1.6字典dict

字典（用"{ }"标识），是除列表以外最灵活的内置数据结构类型。是一种可变容器模型，可存储任意类型对象。  键唯一（不可重复，否则后出现的会替换前者），值可以取任何数据类型

但键必须是不可变的，如字符串，数字或元组。字典的操作都是围绕key展开的。

列表是有序的对象集合，字典是无序的对象集合。字典中的元素是通过键来存取（键值对key-value），而不是通过偏移存取。

1）创建字典 （最后一个键值对后的逗号可有可无）

#创建字典
a = {}
b = dict()#字典初始化：
a = {"id":1,"name":"张三","性别":"男"}dict = {    #推荐写法，可读性更高"id":1,"name":"张三","性别":"男"
}

2） 查找key

•  in或者下标的形式[]，两种方法都很高效（字典背后使用了哈希表）

对于列表list使用in查找是比较低效的（需要遍历），使用[ ]下标索引高效

dict = {    #推荐写法，可读性更高"id":1,"name":"张三","性别":"男"
}#判断键和值是否在字典里
print("id" in dict)   #True 
print("name" in dict)   #True #判断键和值不在字典里
print("id" not in dict)   #False 
print("python" not in dict)   #True #根据key查找对应的value
print(dict["id"])   #1
print(dict["性别"])   #男

dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}print dict['one']          # 输出键为'one' 的值  This is one
print dict[2]              # 输出键为 2 的值  This is two
print tinydict             # 输出完整的字典   {'name': 'runoob','code':6734, 'dept': 'sales'}
print tinydict.keys()      # 输出所有键  ['dept', 'code', 'name']
print tinydict.values()    # 输出所有值  ['sales', 6734, 'runoob']

3）字典的新增（写、修改）

dict["socre"] = 98
dict["班级"] = "S201" 
print(dict)    # {'id': 1, 'name': '张三', '性别': '男', 'socre': 98, '班级': 'S201'}#若key是已经存在的，再次写入即修改
dict["socre"] = 90
print(dict)   #{'id': 1, 'name': '张三', '性别': '男', 'socre': 90, '班级': 'S201'}

4）字典的删除（单一键值对的删除del、和清空字典clear）

tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}del tinydict['Name']  # 删除键是'Name'的条目
tinydict.clear()      # 清空字典所有条目,只保留空字典{}
del tinydict          # 删除整个字典 ，字典变量不存在了

5）字典的遍历（字典的设计初衷不是遍历，而是增删查改），哈希表能以“常数级”时间复杂度完成增删查改。注意！！Java和C++中插入元素顺序，不代表打印顺序（哈希表是无序的），python中做了特殊处理，是有序的。

for key in dict:print(key,dict[key])  #根据key打印对应的值print(dict.keys())   #dict_keys(['id', 'name', '性别', 'socre', '班级'])
print(dict.values())   #dict_values([1, '张三', '男', 90, 'S201'])
print(dict.items())    #dict_items([('id', 1), ('name', '张三'), ('性别', '男'), ('socre', 90), ('班级', 'S201')])for key ,value in dict.items():print(key,value)

6）字典中合法key的类型

使用哈希函数hash能够计算一个变量的哈希值

#可哈希的对象：（不可变对象）
print(hash(0))   #0
print(hash(3.14))   #322818021289917443
print(hash(True))   #1
print(hash("hello"))   #604443049439005304
print(hash((1,2,3)))  #2528502973977326415#不可哈希：列表、字典（因为他们是可变的）

字典、列表、元组是python中常用的内置函数，相比于其他类型（int  str  float）他们的内部可以包含其他元素

---

二、字符串格式化

主要有三种方式：

1. 使用 % 进行格式化

2. 使用 format 函数进行格式化

3. 使用 f-string 进行格式化

（1） % 进行格式化

• %s 表示这个位置接的是一个字符串变量
• %d 表示这个位置接的是一个整型变量

name = "Jack"
age = 18
print("我的名字是: %s，今年 %d 岁" %(name, age))   #我的名字是: Jack，今年 18 岁

（2） format 函数进行格式化

字符串中，使用 {} 进行占位，然后在字符串后跟上 .format() 函数，这个函数的参数就是我们要往字符串中填充的变量。format 函数会依次填充，比如第一个 {} 会取到第一个参数 name，第二个 {} 会取到第二个参数 age

name = "Jack"
age = 18
print("我的名字是:{}, 今年 {} 岁".format(name, age))   #我的名字是:Jack, 今年 18 岁
print("我的名字是:{0}, 今年 {1} 岁".format(name, age))   #同上，带上索引，不容易看错
print("我的名字是:{name}, 今年 {age} 岁".format(name=name, age=age))

（3）使用 f-string 进行格式化

 Python 3.6 才支持的写法，只要你在字符串前面加一个 f，开启 f-string ，就可以在字符中写入变量。

name = "Jack"
age = 18
print(f"我的名字是:{name}, 今年 {age} 岁")  #我的名字是:Jack, 今年 18 岁

三、数据输入和类型转换

对数据内置的类型进行转换，只需要将数据类型作为函数名即可。这些函数返回一个新的对象，表示转换的值。

  (1)input读入一个数据和类型输出

a = int(input())   #input函数输入的是字符串类型，若只要输入整数，将其转化为int型即可
print(a)
print(type(a))

（2）保留浮点数几位小数输

b = float(input())print('%.2f'%b)  #格式化输出：保留数据两位小数
print('{:.2f}'.format(b))

(3)整数转换为浮点数

方法一：
a=float(input())
print('{:.1f}'.format(a), type(a), sep = '\n')方法二：
a=float(input())
print('%.1f'%a, type(a), sep = '\n')方法三：
a=float(input())
print(f'{a :.1f}', type(a), sep = '\n')方法四：
a = int(input())
b = float(a)
print(b)
print(type(b))

 四、简单列表习题练习

（1）列表的拆分（对输入数据划分）

a = input().split()    #split()函数为使用空格拆分字符串 ，
print(a)  
#输入：NiuNiu NiuMei NiuNeng 
#输出：['NiuNiu', 'NiuMei', 'NiuNeng']

 （2）数字列表生成

输入数字字符串，将其转化为列表输出

#方法一·:
a = input().split()  #分割字符串
b = []  #创建一个空列表
for i in a:     #遍历输入字符串b.append(int(i))  #将每次遍历获取到的元素添加到列表
print(b)  #打印列表#方法二：
print([int(i) for i in input().split()])   #利用列表解析快速创建列表
#-------------------------------------------------------------------------
#将输入字符串转化为列表，再在列表后添加元素
Name = input().split()
listName = []
for i in Name:  #在输入中遍历listName.append(i)   #将每个字符串添加到列表#在末尾添加元素
listName.append('Allen')
print(listName)#在指定位置添加元素
listName.insert(0,'Allen')
print(listName)

(3)列表排序

• sorted（）只是临时排序，不会改变原来的列表
• sort（）会改变原来的列表，同时添加参数reverse可反转列表

my_list = ['P','y','t','h','o','n']print(sorted(my_list))   #输出排序列表：['P', 'h', 'n', 'o', 't', 'y']
print(my_list)   #输出源列表，因为sorted不改变源列表['P','y','t','h','o','n']
my_list.sort(reverse=True)  #源列表反转
print(my_list)   #输出原列表反转后的列表['y', 't', 'o', 'n', 'h', 'P']

（4）密码游戏：

输入一个四位数字，通过位置的交换和对应位置数字的改变，输出四位整数：

#方法一：
num = input()
b = []  
for i in num:a = int(i)a = (a + 3) % 9   #改变数字b.append(a) c = b[2]*1000 + b[3]*100 + b[0]*10 + b[1]   #数字交换
print('{:0>4}'.format(c))   #输出四位数字#方法二：
num1=input()
num1=list(num1)a=[]
for i in range(0,4):x=str((int(num1[i])+3)%9)a.append(x)
x=a[0]
a[0]=a[2]
a[2]=x
y=a[1]
a[1]=a[3]
a[3]=y
print(''.join(a))