本文实例讲述了Python变量、数据类型、数据类型转换相关函数用法。分享给大家供大家参考,具体如下:
python变量的使用不需要进行类型声明(类型名 变量名),给一个变量名赋什么值就是什么类型。
- 变量的赋值使用 =
说明:虽然python声明变量时没有一个类型来圈注,但它并不是弱类型语言,相反,它是一门强类型语言。
- 弱类型的语言的东西没有明显的类型,它能随着环境的不同自动变换类型;
- 而强类型则没这样的规定,不同类型间的操作有严格定义,只有相同类型的变量才能操作
为什么说 Python 是强类型语言
Python变量命名规则:
- 变量名只能是 字母、数字或下划线的任意组合
- 变量名的第一个字符不能是数字
- 不能与关键字重名(关键字用着用着就记熟了)
数据类型
整数int类型:
python3中移除了python2中的long
Python3中没有限制int数值的大小
- 可以用其他数制来表示数值:二进制是以0b开头的,8进制是以0O(第二个是英文o,大小写都可以)开头的,16进制是以0x开头的
1
|
2
3
4
5
6
7
8
9
10
11
12
|
>>> i = 0b1111 >>> print (i) 15 >>> i = 0x0010 >>> print (i) 16 >>> i = 0o0010 >>> print (i) 8 >>> i = 0O0010 >>> print (i) 8 |
小数float类型:
- 可以用小数表示:3.1415,1.5,.......
-
也可以用科学计数法表示(10用e替代,比如0.000012可以写成
1.2e-5)
1
|
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
>>> a = 1.5 >>> print (a) 1.5 >>> a = - 9999.5 >>> print (a) - 9999.5 >>> a = 1.5e5 >>> print (a) 150000.0 >>> a = 1.5e - 10 >>> print (a) 1.5e - 10 >>> a = 0.0000000000000001 >>> print (a) 1e - 16 |
注:对于太小的数,会自动转化成科学计数法表示,太大的数不会自动转化
布尔bool类型:True、False
- 使用True和False两个关键字来表示布尔类型
- 可以使用非零数值表示True,但总觉得这是一个不好的习惯
1
|
2
3
4
5
6
7
8
9
10
11
12
|
>>> type ( True ) < class 'bool' > >>> type ( False ) < class 'bool' > >>> a = bool ( 2 ) >>> a True >>> a = int ( True ) >>> a 1 >>> print ( int ( False )) 0 |
字符串str类型:
-
Python不支持字符类型; 字符会被视为长度为
1
的字符串 - 可以使用两个单引号,或两个双引号来代表字符串
1
|
2
3
4
|
>>> type ( "aaaa" ) < class 'str' > >>> type ( 'aaaa' ) < class 'str' > |
- 可以使用下标来访问字符串的值【-1代表最后一位】:
1
|
2
3
4
5
|
>>> str1 = "123" >>> str1[ 0 ] '1' >>> str1[ - 1 ] '3' |
- 可以对字符串进行切片(切片方法:字符串名[左下标:右下标(不取到右下标)]),返回值是切片后的字符串,但并不会改变原字符串的值
【 [:]代表完全切片,[:右下标]代表从零开始,[左下边:]代表结尾是最后一位,-1下标代表最后一位 】
【切片也可以有间隔,用法字符串名[左下标:右下标:间隔] 】
1
|
2
3
4
5
6
7
8
9
10
|
>>> hello = "hello world!" >>> new_hello = hello[:] >>> new_hello 'hello world!' >>> hello[: 2 ] 'he' >>> hello[ 1 : 3 ] 'el' >>> hello[ 1 : - 1 ] 'ello world' |
1
|
2
3
4
|
>>> hello[ 1 : - 1 : 1 ] 'ello world' >>> hello[ 1 : - 1 : 2 ] 'el ol' |
- 可以使用三引号(单引号或双引号)来代表多行字符串
1
|
2
3
4
5
6
7
8
|
>>> type ( """hahah haha hahah""" ) < class 'str' > >>> type ( '''第一行 第二行 第三行''' ) < class 'str' > |
- 常用函数:补充
- 字符串格式化:补充
- 原始字符串:补充
列表list类型:
- list是一种有序的集合,可以随时添加和删除其中的元素。
- 使用中括号包裹元素,表明这是一个列表。[元素,元素,元素,.......]
1
|
2
3
|
>>> i = [ 'a' , 100 , True ] >>> type (i) < class 'list' > |
- 列表的元素不限定数据类型,可以是字符串,可以是数值,可以是布尔类型,也可以是其他列表等等
- 列表可以是空的:list1=[]
- 可以使用list函数来创建列表
1
|
2
|
>>> list ( "abcd" ) [ 'a' , 'b' , 'c' , 'd' ] |
- 列表也可以使用下标来访问元素,也可以切片,操作与字符串相同。
- 列表可以替换元素【使用 = 】:
1
|
2
3
4
5
|
>>> i [ 'a' , 100 , True ] >>> i[ 0 ] = 'b' >>> i [ 'b' , 100 , True ] |
- 如果列表中包含列表时,如果要取子列表中的元素,相当于操作“二维数组”,使用 列表名[索引][索引]:
1
|
2
3
4
5
6
7
|
>>> i [ 'b' , 100 , True ] >>> l = [i, "helloworld" ] >>> l [[ 'b' , 100 , True ], 'helloworld' ] >>> l[ 0 ][ 0 ] 'b' |
- 可以使用“+”拼接列表,使用*重复列表
1
|
2
3
4
5
6
|
>>> l2 = i * 2 >>> l2 [ 'b' , 100 , True , 'b' , 100 , True ] >>> l3 = i + l >>> l3 [ 'b' , 100 , True , [ 'b' , 100 , True ], 'helloworld' ] |
- 列表常用函数:补充
- 列表生成式:补充
元组tuple类型:
- 使用()跟,来表示元组,当tuple中只有一个元素时,逗号可以特别的说明这是一个tuple,实际上,python也允许tuple定义时没有括号
1
|
2
3
4
5
6
7
8
9
10
|
>>> t1 = ( 'a' , 1 , True ) >>> type (t1) < class 'tuple' > >>> t2 = ( 'a' ) >>> type (t2) < class 'str' > >>> ####注意上面的类型### >>> t3 = ( 'a' ,) >>> type (t3) < class 'tuple' > |
1
|
2
3
4
5
|
>>> tuple2 = 1 , 2 , 3 , 4 , 5 >>> type (tuple2) < class 'tuple' > >>> tuple2 ( 1 , 2 , 3 , 4 , 5 ) |
- 有序列表叫元组,tuple的元素一旦初始化就不能修改,但可以存储list,因为tuple并不会复制一份list到自己的内存中,它只会存储list的内存指向,只要list的内存指向不变,就不跟tuple的不变原则冲突。
1
|
2
3
4
5
6
7
|
>>> t1 = ( 'a' ,i) >>> t1 ( 'a' , [ 'b' , 100 , True ]) >>> id (t1[ 1 ]) 1673650817160 >>> id (i) 1673650817160 |
- tuple也可以可以使用下标来访问元素,也可以切片,操作与字符串相同。
- 元组可以为空
-
元组常用函数
tuple一旦初始化就不能修改,所以它没有append()、insert(),也没有pop()等能增删元素的方法
12345>>> tuple1
=
(
1
,
2
,
3
,
4
)
>>>
print
(tuple1.index(
2
))
#查找指定元素的下标
1
>>>
print
(tuple1.count(
2
))
#查找某元素存在的数量
1
字典dict类型:
- 使用键-值(key-value)存储
- 由于其哈希特性,因此具有极快的查找速度
- 可以使用{键1:值1,键2:值2,键3:值3 ...}来定义一个字典
1
|
2
3
|
>>> d1 = { 'a' : 'apple' , 'b' : 'banana' , 'c' : 'cabbage' } >>> type (d1) < class 'dict' > |
- 字典是使用哈希算法来计算对应对应值的位置的,所以key必须是固定不可变的,在Python中,字符串、整数等都是不可变的,所以,可以作为key。其余元素可变的对象如list、set、dict就不能作为key,因为其元素结果不确定,无法确定哈希值。
1
|
2
3
4
5
6
|
>>> l1 = [ 'a' ] >>> d1[l1] = 'c' Traceback (most recent call last): File "<pyshell#5>" , line 1 , in <module> d1[l1] = 'c' TypeError: unhashable type : 'list' |
- dict内部存放的顺序和key放入的顺序是没有关系的
- 可以使用 字典名[键] 快速查找出对应的值,键不存在则无法查找
1
|
2
3
4
5
6
7
8
9
|
>>> d1 { 'a' : 'apple' , 'b' : 'banana' , 'c' : 'cabbage' , ( 'a' ,): 'c' } >>> d1[ 'a' ] 'apple' >>> d1[ 'd' ] Traceback (most recent call last): File "<pyshell#17>" , line 1 , in <module> d1[ 'd' ] KeyError: 'd' |
- 可以给某一个键的对应的值重新赋值,但由于一个key只能对应一个value,所以新的赋值会把就得值覆盖掉【如果定义的时候出现多个同名的键,这个键的值以最后的赋值为准】
1
|
2
3
4
5
|
>>> d1 { 'a' : 'apple' , 'b' : 'banana' , 'c' : 'cabbage' , ( 'a' ,): 'c' } >>> d1[ 'a' ] = 'apple pen' >>> d1 { 'a' : 'apple pen' , 'b' : 'banana' , 'c' : 'cabbage' , ( 'a' ,): 'c' } |
- 可以使用 字典名[一个未使用的键]=值 来添加一个键值对:
1
|
2
3
4
5
|
>>> d1 { 'a' : 'apple pen' , 'b' : 'banana' , 'c' : 'cabbage' , ( 'a' ,): 'c' } >>> d1[ 'ai' ] = 'python' >>> d1 { 'a' : 'apple pen' , 'b' : 'banana' , 'c' : 'cabbage' , ( 'a' ,): 'c' , 'ai' : 'python' } |
- 注:直接迭代字典,只能迭代出key
1
|
2
3
4
5
6
|
>>> dict10 = { 1 : "苹果" , "雪碧" : "雪梨" } >>> >>> for i in dict10: print (i) 1 雪碧 |
- 使用 字典名[key] 获取不存在的键时会抛出异常KeyError,可以使用成员运算符来避免或使用get()来避免
1
|
2
3
4
5
6
7
8
9
10
|
>>> dict10 { 1 : '苹果' , '雪碧' : '雪梨' } >>> 1 in dict10 True >>> 3 in dict10 False >>> print (dict10.get( 3 )) None >>> print (dict10.get( 1 )) 苹果 |
- 字典常用函数:补充
集合类型:
- set和dict类似,也是使用大括号包裹
- 可以使用大括号来定义一个集合
1
|
2
3
4
5
|
>>> s1 = { 'a' , 'b' , 'c' } >>> s1 { 'b' , 'c' , 'a' } >>> type (s1) < class 'set' > |
- 可以使用set来定义一个集合,set函数的参数为一个可迭代对象(Iterable)
1
|
2
3
4
5
6
|
>>> s2 = set () >>> type (s2) < class 'set' > >>> s3 = set ([ 'a' , 'b' , 'c' ]) >>> type (s3) < class 'set' > |
- set不能使用下标来取出元素
- set的原理和dict一样,所以,同样不可以放入可变对象,因为它也是使用哈希来计算计算结果的,可以记作set与dict不同的是它只存储key,不存储value【set()函数传入一个字典作为参数时,只取key作为结果】
1
|
2
3
4
5
|
>>> s3.add([ 'cbd' ]) Traceback (most recent call last): File "<pyshell#37>" , line 1 , in <module> s3.add([ 'cbd' ]) TypeError: unhashable type : 'list' |
- 集合的常用函数:补充
数据类型转换相关函数:
-
int()
函数可以把其他数据类型转换为整数: - float( )函数可以把其他数据类型转换成浮点数
- str( )函数可以把其他数据类型转换成字符串类型
- bool( )函数可以把其他数据类型转换成布尔类型
- tuple()将其他数据类型转换为元组。
- set()将其他数据类型转换为集合。
1
|
2
3
4
5
6
7
8
9
10
11
12
13
14
|
>>> print ( type ( int ( "123" ))) < class 'int' > >>> print ( type ( float ( "123" ))) < class 'float' > >>> float ( "123" ) 123.0 >>> str ( 123 ) '123' >>> bool ( 2 ) True >>> list ( "123" ) [ '1' , '2' , '3' ] >>> tuple ( "123" ) ( '1' , '2' , '3' ) |
注:转换是有规则的,要符合规则才能转化,比如int()不能转换"abc"
希望本文所述对大家Python程序设计有所帮助。
原文链接:https://www.cnblogs.com/progor/p/8401900.html