目录
一、数据类型
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/False
counter = 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)他们的内部可以包含其他元素
二、字符串格式化
主要有三种方式:
使用 % 进行格式化
使用 format 函数进行格式化
使用 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))