python基本数据类型Number,String,list,tuple,set,dict、日期用法以及遍历方法

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

等号（=）用来给变量赋值。

等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。例如：

#!/usr/bin/python3
 
counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "runoob"     # 字符串
 
print (counter)
print (miles)
print (name)

 

Python3 中有六个标准的数据类型：

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

Python3 的六个标准数据类型中：

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

 

1.   Python3 数字类型(Number)

Python 数字数据类型用于存储数值。

数据类型是不允许改变的,这就意味着如果改变数字数据类型的值，将重新分配内存空间。

以下实例在变量赋值时 Number 对象将被创建：

var1 = 1
var2 = 10

您也可以使用del语句删除一些数字对象的引用。

del语句的语法是：

del var1[,var2[,var3[....,varN]]]]

(1)基本的+-*/

#!/usr/bin/python3
 
number=10
number=number+10
print(number)
number+=10
print(number)
number=number*10
print(number)
number*=10
print(number)
number-=10
print(number)
number/=10
print(number)

(2)n次方与求开n次跟(建议使用2**3求n次方)

>>> import math
>>> math.pow(2,3)
8.0
>>> 2**3

>>> 8**(1/3)
2.0
>>>

(3)数学函数

函数	返回值 ( 描述 )
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y)	如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃 。使用 使用 (x>y)-(x<y) 替换。
exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)	返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,...)	返回给定参数的最小值，参数可以为序列。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	x**y 运算后的值。
round(x [,n])	返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x)	返回数字x的平方根。

(4)随机数函数

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。

Python包含以下常用随机数函数：

函数	描述
choice(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange ([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
random()	随机生成下一个实数，它在[0,1)范围内。
seed([x])	改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst)	将序列的所有元素随机排序
uniform(x, y)	随机生成下一个实数，它在[x,y]范围内。

(5)三角函数

函数	描述
acos(x)	返回x的反余弦弧度值。
asin(x)	返回x的反正弦弧度值。
atan(x)	返回x的反正切弧度值。
atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值。
cos(x)	返回x的弧度的余弦值。
hypot(x, y)	返回欧几里德范数 sqrt(x*x + y*y)。
sin(x)	返回的x弧度的正弦值。
tan(x)	返回x弧度的正切值。
degrees(x)	将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x)	将角度转换为弧度

(6)数学常量

常量	描述
pi	数学常量 pi（圆周率，一般以π来表示）
e	数学常量 e，e即自然常数（自然常数）

 

0.  字符串类型 String

字符串是 Python 中最常用的数据类型。我们可以使用引号( ' 或 " )来创建字符串。Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。
创建字符串很简单，只要为变量分配一个值即可。

(1)定义以及截取

#!/usr/bin/python3
 
var1 = 'Hello World!'
var2 = "zhangsa"
 
print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])

结果:

var1[0]: H
var2[1:5]: hang

(2)字符串是不可变类，类似于Java的字符串类型：

#!/usr/bin/python3
 
var1 = 'Hello World!'
var2 = var1

var1 = var1[:6] + "ZHANGSAN"
 
print ("var1: ", var1)
print ("var2: ", var2)

结果:

var1: Hello ZHANGSAN
var2: Hello World!

(3)python转义字符

在需要在字符中使用特殊字符时，python用反斜杠(\)转义字符。如下表：

转义字符	描述
\(在行尾时)	续行符(类似于Properties文件的换行符)
\\	反斜杠符号
\'	单引号
\"	双引号
\a	响铃
\b	退格(Backspace)
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy 代表的字符，例如：\o12 代表换行，其中 o 是字母，不是数字 0。
\xyy	十六进制数，yy代表的字符，例如：\x0a代表换行
\other	其它的字符以普通格式输出

例如:续行符以及转义'

#!/usr/bin/python3
 
var1 = 'Hello World!'
var2 = var1

var1 = var1[:6] + "ZHAN\
GSAN,welcome to \'China\'"
 
print ("var1: ", var1)
print ("var2: ", var2)

结果:

var1: Hello ZHANGSAN,welcome to 'China'
var2: Hello World!

(4)字符串运算符

下表实例变量a值为字符串 "Hello"，b变量值为 "Python"：

操作符	描述	实例
+	字符串连接	a + b 输出结果： HelloPython
*	重复输出字符串	a*2 输出结果：HelloHello
[]	通过索引获取字符串中字符	a[1] 输出结果 e
[ : ]	截取字符串中的一部分，遵循左闭右开原则，str[0,2] 是不包含第 3 个字符的。	a[1:4] 输出结果 ell
in	成员运算符 - 如果字符串中包含给定的字符返回 True	'H' in a 输出结果 True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True	'M' not in a 输出结果 True
r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。	print( r'\n' ) print( R'\n' )
%	格式字符串	请看下一节内容。

 

例如:

#!/usr/bin/python3
 
a = "Hello"
b = "Python"
 
print("a + b 输出结果：", a + b)
print("a * 2 输出结果：", a * 2)
print("a[1] 输出结果：", a[1])
print("a[1:4] 输出结果：", a[1:4])
 
if( "H" in a) :
    print("H 在变量 a 中")
else :
    print("H 不在变量 a 中")
 
if( "M" not in a) :
    print("M 不在变量 a 中")
else :
    print("M 在变量 a 中")
 
print (r'\n')
print (R'\n')

结果:

a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell
H 在变量 a 中
M 不在变量 a 中
\n
\n

(5)python字符串格式化

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。

#!/usr/bin/python3
 
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))

结果:

我叫 小明 今年 10 岁!

 

也可以用下面格式：

print("{} 什么意思".format(2233))
print("{} 什么意思".format("1122"))
print("%s 什么意思" % "1122")

结果：

2233 什么意思
1122 什么意思
1122 什么意思

 

python字符串格式化符号:

符   号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%f 和 %E 的简写
%p	用十六进制数格式化变量的地址

 

(6)三行符:

python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。实例如下

#!/usr/bin/python3
 
para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
para_str2 = r"""这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)
print (para_str2)

结果:

这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( )。
也可以使用换行符 [
]。

这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。

 

三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。

一个典型的用例是，当你需要一块HTML或者SQL时，这时用字符串组合，特殊字符串转义将会非常的繁琐。

errHTML = '''
<HTML><HEAD><TITLE>
Friends CGI Demo</TITLE></HEAD>
<BODY><H3>ERROR</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="window.history.back()"></FORM>
</BODY></HTML>
'''
cursor.execute('''
CREATE TABLE users (  
login VARCHAR(8), 
uid INTEGER,
prid INTEGER)
''')

3.list类型

　　类似于java的list类型，数据集合，可以追加元素与删除元素。

　　遍历list可以用下标进行遍历，也可以用迭代器遍历list集合

　　建立list的时候用[]括号

import sys
list1 = [ 'zhangsan' , 'lisi' , 'wangyu' ]
#  直接打印集合
print(list1)

#  c从0开始，类似于java
print(list1[1])

# 负号代表倒着数
print(list1[-1])

#  打印集合长度
print(len(list1))

# 追加元素
list1.append("john")
print(list1)
print(list1[-1])


# 插入到指定位置
list1.insert(1, 'john1')
print(list1)

#  删除元素
#  删除最后一个元素
list1.pop()
print(list1)

#  删除指定位置的元素
del_o= list1.pop(0)  # del_0记录删除的元素
print(list1)
print(del_o)



#  修改(直接覆盖指定位置的值)


# 通过迭代器遍历list的两种方式(for和while)
it = iter(list1)    # 创建迭代器对象
for x in it:
    print (x, end=" ")

it1 = iter(list1)    # 创建迭代器对象
print()
while True:
    try:
        print(next(it1), end='  ')
    except StopIteration:
        sys.exit()

list 也可以用for in 直接遍历

list1 = [{'name': 'zs'}, {'name': 'ls'}, {'name': 'zl'}]
for user in list1:
    print(user)

list2 = [1, 2, 3, 4, 5]
for num in list2:
    print(num)

结果：

{'name': 'zs'}
{'name': 'ls'}
{'name': 'zl'}
1
2
3
4
5

 

补充:通过enumerate方法遍历集合

　　enumerate方法将list的值与下标包装成一个tuple

# 1.迭代list
# 使用enumerate方法。
L = ['zhangsan', 'lisi', 'wangwu']
# 使用enumerate方法处理集合后集合变为包含tuple的集合    [(0,'zhangsan'),(1,'lisi'),(2,'wangwu')]
# tuple的特性是:拿一个元素接tuple会将整个tuple赋给此元素，拿与tuple长度相等元素接tuple会将tuple的值依次赋给元素
# 第一种遍历方法
for index,value in enumerate(L):
    print(index, '-', value)

# 第二种方法
for t in enumerate(L):
    print(t[0], '-', value)

list也可以限定类型： 这样可以直接遍历然后调用相关方法

# list 也可以限定类型
list1: list[int] = []
list1.append(1)
list1.append(2)

print(list1)

# 下面两个等价
print(list1.__class__)
print(type(list1))

结果：

[1, 2]
<class 'list'>
<class 'list'>

4.tuple类型

　　与list不同的是元素不可以变，不可以追加元素。元组使用小括号，列表使用方括号。

　　遍历tuple可以用下标遍历

　　tuple用()括号建立

# tuple类似于list，只是一旦创建不可改变
tuple1=('zhangsan', 'lisi', 'wangwu')
print(tuple1)
print(tuple1[1])
print(tuple1[-1])

# 只有一个int型的tuple
tuple2=(1,)
print(tuple2[0])

# tuple中有list的情况，list中的元素可以进行增删改
tuple3=('zhangsan','lisi',['wangwu','zhaoliu'])
print(tuple3)
print(tuple3[-1])
tuple3[-1].append('tianqi') # tuple中的list集合中添加元素
print(tuple3)
tuple3[-1][0]='sunwu' #修改tuple中的list中的元素值
print(tuple3)



# 用多个值接tuple会将tuple的元素分别赋给对应元素的值
tuple4=(1, 2)
x, y = tuple4
print(x, y)

tuple  类型必须用()， 且(1,) 标识元组类型，如果是(1), 会被作为int 处理：

test1 = (1)
test2 = (1,)
print(test1.__class__)
print(test1)
print(test2.__class__)
print(test2)

 

结果：

<class 'int'>
1
<class 'tuple'>
(1,)

 

5.set类型

　　与list不同的是不能有重复元素，而且存储的是不可变对象。

　　遍历set不可以用下标（set是无序集合）

　　建立set用set([])建立，括号中也可以传入一个集合。可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

# set用法，set与list一样，只是存储的不能有重复元素，其次存储的是不可变对象，类似于list就是可变对象
# 创建set(如果集合中有重复元素会自动删除重复元素)
# set1=set([1,2,'kkk',3,'wiwiwi'])
set1 = {1,2,'kkk',3,'wiwiwi'}
print(set1)
print("set1的长度此时是:", len(set1))

# 遍历set(只能用下面这种方式遍历，不能根据下标遍历，set元素没有下标)
for ele in set1:
    print(ele)

# 追加元素(如果元素不存在会加入到set中，如果元素存在则不会追加)
set1.add("mmm")
print(set1)

# 删除元素(如果直接删除而元素不存在于set中会报错)
if 'mmm' in set1:
    set1.remove('mmm')
print(set1)

结果:

{1, 2, 3, 'kkk', 'wiwiwi'}
set1的长度此时是: 5
1
2
3
kkk
wiwiwi
{1, 2, 3, 'kkk', 'wiwiwi', 'mmm'}
{1, 2, 3, 'kkk', 'wiwiwi'}

 

6.dict类型(类似于java的map)

　　dict类型存储的键值对，类似于java的map

　　不可以用下标遍历，可以用in遍历dict的key，通过key获取value

　　创建的时候用{key:value,key1:value1...}

# dict类型练习
# 定义一个dict类型
dict1={"zhangsan": 100,"lisi": 999,"wangwu":99}
print(len(dict1))
print(dict1["zhangsan"])
if "tianqi" in dict1:
    print(dict1["tianqi"])
else:
    print("tianqi is not in dict1")

# 更新dict
dict1["zhangsan"]=0
# 追加元素
dict1["tianqi"]=100
# 删除字典元素
del dict1["wangwu"]

# 循环遍历dict
for key in dict1:
    print("key:",key,"value:",dict1[key])

补充： dict删除以及动态赋值操作 

# dict类型练习: 删除值，获取值，动态放值
# 定义一个dict类型
dict1={"zhangsan": 100,"lisi": 999,"wangwu":99}
print(dict1)

# 弹出一个key, 且必须存在dict 中，否则会报错
result = dict1.pop("lisi")
print(result)
print(dict1)

# 动态放值，有值的时候不会再次覆盖
dict1.setdefault("dy1", "dy1value")
dict1.setdefault("dy1", "dy1value2")
print(dict1.get("dy1"))

print(dict1)

结果：

{'zhangsan': 100, 'lisi': 999, 'wangwu': 99}
999
{'zhangsan': 100, 'wangwu': 99}
dy1value
{'zhangsan': 100, 'wangwu': 99, 'dy1': 'dy1value'}

补充:

dict 对象有一个 values() 方法，这个方法把dict转换成一个包含所有value的list，这样，我们迭代的就是 dict的每一个 value

items() 方法把dict对象转换成了包含tuple的list，对list进行迭代即可同时获得key和value

# 2.迭代dict
# 2.1 迭代dict的value
# 2.1.1第一种方法 使用dict.value()方法
# dict 对象有一个 values() 方法，这个方法把dict转换成一个包含所有value的list，这样，我们迭代的就是 dict的每一个 value：
dict1={"zhangsan": 100,"lisi": 999,"wangwu":99}
values = dict1.values()
print(values) #[100, 999, 99]
# 遍历value集合
for ele in values:
    print(ele)

# 2.2 迭代dict的key 和 value   使用items方法(会将dict的key和value变成tuple)
# items() 有一个对应的 iteritems()，iteritems() 不把dict转换成list，而是在迭代过程中不断给出 tuple，所以， iteritems() 不占用额外的内存。
print(dict1.items())
# [('zhangsan', 100), ('lisi', 999), ('wangwu', 99)]
# 第一种遍历
for t in dict1.items():
    print(t[0], '-',  t[1])

# 第二种遍历
for key,value in dict1.items():
    print(key, '-', value)

补充：日期类以及转换计算相关方法 

import time
from datetime import datetime, timedelta

'''
time 模块简单使用
'''
print("========1")
# 字符串转为时间戳
t = "2017-11-24 17:30:00"  # 将其转换为时间数组
timeStruct = time.strptime(t, "%Y-%m-%d %H:%M:%S")
print(time.mktime(timeStruct))
# 转换为时间戳:
timeStamp = int(time.mktime(timeStruct))
print(timeStamp)

print("========2")
# 时间戳转为字符串
strTime = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(timeStamp))
print(strTime)

print("========3")
# 当前时间
curr = time.time()
print(curr)
print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(curr)))

'''
datetime 模块简单使用
'''
print("========4")
i = datetime.now()
print("当前的日期和时间是 %s" % i)
print("ISO格式的日期和时间是 %s" % i.isoformat())
print("当前的年份是 %s" % i.year)
print("当前的月份是 %s" % i.month)
print("当前的日期是 %s" % i.day)
print("dd/mm/yyyy 格式是  %s/%s/%s" % (i.day, i.month, i.year))
print("当前小时是 %s" % i.hour)
print("当前分钟是 %s" % i.minute)
print("当前秒是  %s" % i.second)

# 当前日期减去三天
print("========5")
# 先获得时间数组格式的日期
threeDayAgo = (datetime.now() - timedelta(days=3))
print("三天前的日期和时间是 %s" % threeDayAgo)
# 转换为时间戳:
timeStamp = int(time.mktime(threeDayAgo.timetuple()))
# 转换为其他字符串格式:
strTime = threeDayAgo.strftime("%Y-%m-%d %H:%M:%S")
print(strTime)

结果：

========1
1511515800.0
1511515800
========2
2017-11-24 17:30:00
========3
1658995764.316633
2022-07-28 16:09:24
========4
当前的日期和时间是 2022-07-28 16:09:24.316633
ISO格式的日期和时间是 2022-07-28T16:09:24.316633
当前的年份是 2022
当前的月份是 7
当前的日期是 28
dd/mm/yyyy 格式是  28/7/2022
当前小时是 16
当前分钟是 9
当前秒是  24
========5
三天前的日期和时间是 2022-07-25 16:09:24.316633
2022-07-25 16:09:24

补充： python可以进行类型强转，比如我们的一些返回值，不知道类型无法使用其API，我们可以进行类型强转后使用对应类型的API，比如： 

def testFun(param):
    # 类型强转，强转之后就可以使用对应类型的API方法
    paramDict = dict(param)
    print(paramDict.get("test"))

str1 = "11122"
print(str1.__class__)
int1 = int(str1)
print(int1.__class__)
print("======")
print(str1)
print(int1)

testFun({"test": "testvalue"})

结果：

<class 'str'>
<class 'int'>
======
11122
11122
testvalue

 

补充:isinstance和type 可用于判断类型

isinstance 和 type 的区别在于：

• type()不会认为子类是一种父类类型。
• isinstance()会认为子类是一种父类类型。

#!/usr/bin/python3
 
counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "runoob"     # 字符串
 
print (type(counter))
print (type(miles))
print (type(name))

print (isinstance(counter, int))
print (isinstance(miles, float))
print (isinstance(name, str))

结果:

<class 'int'>
<class 'float'>
<class 'str'>
True
True
True