Python叁数据类型,Python数据定义

图片 3
ca88会员登录中心

  从刚接触Python到近日曾经有段时日了,向来未曾时间静下心来好好的写点东西,一向都在闷头往前扎,随俗浮沉。那两日突然意识从前学的东西固然每一部分都有做过小结,然而全体框架貌似并从未,幸好,今后补还赶得及。

数据类型:

前言

Python三的数据类型有多样,即其有五个正规的数据类型:

  • Number(数字)
  • String(字符串)
  • List(列表)
  • Tuple(元组)
  • Sets(集合)
  • Dictionary(字典)

  直接奔向宗旨,学任何编制程序语言确定要读书其所含有的变量类型,python常用变量的档案的次序如下(截图省事):

  什么是数码?

壹.主旨数据类型(Number)

二个先后要运营,就要先描述其算法。描述三个算法应先表达算法中要用的数据,数据以变量或常量的样式来描述。每一个变量或常量都有数据类型。Python叁的主题数据类型有4种:
整型(int)、浮点型(float)、 布尔型(bool)、complex(复数)。

1.在Python3里,只有一种整数类型 int,表示为长整型,没有 python2 中的 Long。
2.像大多数语言一样,数值类型的赋值和计算都是很直观的。
3.内置的 type() 函数可以用来查询变量所指的对象类型。

Python还支持复数,复数由实数部分和虚数部分构成,能够用a + bj,或者complex(a,b)意味着,
复数的实部a和虚部b都是浮点型

a, b, c, d = 20, 5.5, True, 4+3j  # Python允许你同时为多个变量赋值 
print(type(a), type(b), type(c), type(d)) # 输出结果: <class 'int'> 
<class 'float'> <class 'bool'> <class 'complex'>

其它仍可以用 isinstance 来判别项目:

a, b, c, d = 20, 5.5, True, 4+3j
isinstance(a, int)  # 输出结果: True

sinstance 和 type 的界别在于:

  • type()不会感觉子类是壹种父类类型。
  • isinstance()会感到子类是1种父类类型。

class A:
    pass

class B(A):
    pass

isinstance(A(), A)  # returns True
type(A()) == A      # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False

图片 1

    在计算机科学中,数据是指具备能输入到Computer并被Computer程序管理的符号的介质的总称,是用以输入电子计算机实行拍卖,具有一定意义的数字字母、符号和模拟量等的统称。今后计算机存储和拍卖对象十二分周边,表示这几个目的的数码也随后变得越来越复杂。

1.1 bool(布尔值)

  • 在 Python二 中是未曾布尔型的,它用数字 0 表示 False,用 一 表示
    True。到 Python叁 中,把 True 和 False 定义成最重要字了,但它们的值还是一 和 0,它们得以和数字相加。
  • 除此以外布尔值可以用and、or和not运算。
  • not运算是非运算,它是四个单目运算符,把True形成False,False产生True:

>>> True and True
True
>>> True and False
False
>>> False and False
False
>>> 5 > 3 and 3 > 1
True
>>> True or True
True
>>> True or False
True
>>> False or False
False
>>> 5 > 3 or 1 > 3
True
>>> not True
False
>>> not False
True
>>> not 1 > 2
True

 

  举个例证:

1.二 数值运算

  • Python能够同时为多个变量赋值,如a, b = ①, 二。
  • 二个变量能够通过赋值指向分裂种类的目的。
  • 数值的除法(/)总是回到3个浮点数,要拿走整数使用//操作符。
  • 在混合总计时,Python会把整型转变到为浮点数。

>>> 5 + 4  # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7  # 乘法
21
>>> 2 / 4  # 除法,得到一个浮点数
0.5
>>> 2 // 4 # 除法,得到一个整数
0
>>> 17 % 3 # 取余 
2
>>> 2 ** 5 # 乘方
32

  1、数字常量(Number)

 在娱乐个中你会有您的和谐的人物、器材、品级、金钱等等、这一个都是数码,不过在Python中那几个数据都有投机独家的品类那么他们该怎么表示呢?

一.2 del语句删除一些目标引用

del语句的语法是:del var1[,var2[,var3[....,varN]]]]
您能够经过行使del语句删除单个或五个对象。举个例子:

del var
del var_a, var_b

    正是阿拉伯数字,int(整型),long(长整型),float(浮点型,正是带小数点的),complex(复数,(实部+虚部)),假如想要深切研究各种品种的界定能够参照Computer组成原理。

1 例如用cs来说
2 名字:Chares_Lee-------------------->字符串
3 金钱:7500        ---------------------->数字
4 装备:AK-47,闪光弹,防弹衣 --------->列表
5 击杀数:15         ------------------------>数字
6 等等,还有很多其他类型的数据,处理不同类型的数据就需要定义不同的数据类型

二.String(字符串)

Python中的字符串用单引号('')或双引号("")括起来,同时利用反斜杠(\)转义特殊字符。

 

1 基本的数据类型有:

二.一 字符串的截取、拼接
  • 变量[头下标:尾下标]
  • 索引值以 0 为始发值,-一 为从末了的始发地点。
  • 加号 (+) 是字符串的连接符, 星号 (*)
    表示复制当前字符串,紧跟的数字为复制的次数。

#!/usr/bin/python3

str = 'Runoob'

print (str)          # 输出字符串
print (str[0:-1])    # 输出第一个到倒数第二个的所有字符
print (str[0])       # 输出字符串第一个字符
print (str[2:5])     # 输出从第三个开始到第五个的字符
print (str[2:])      # 输出从第三个开始的后的所有字符
print (str * 2)      # 输出字符串两次
print (str + "TEST") # 连接字符串

实行以上程序会输出如下结果:

Runoob
Runoo
R
noo
noob
RunoobRunoob
RunoobTEST

  贰、布尔类型(bool)

 数字(整型、长整型、浮点、布尔、复数)

二.二 转义特殊字符

Python
使用反斜杠(\)转义特殊字符,假使您不想让反斜杠发生转义,能够在字符串前面增添二个r,表示原始字符串:

>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
>>> 

另外,反斜杠(\)能够看成续行符,表示下壹行是上一行的接续。也能够使用
“””…””” 或然 ”’…”’ 跨更多行(只限终端交互方式)。

>>> print('''line1
... line2
... line3''')
line1
line2
line3

注意,Python 没有单独的字符类型,四个字符正是长度为一的字符串。

>>> word = 'Python'
>>> print(word[0], word[5])
P n
>>> print(word[-1], word[-6])
n P

    唯有True(真) 和 False(假)两种等级次序(C语言习于旧贯用一 /
0),一般用在逻辑剖断式。

一.平头:根据字面包车型大巴情趣俩知情就从非常的大数点的数

二.叁 Python中的字符串不能退换

与 C 字符串分裂的是,Python
字符串无法被转移。向3个目录位置赋值,比方word[0] = ‘m’会导致错误。

>>> word = 'Python'
>>> word[0] = 'm'  #会导致错误

  

2.长整数:正是十分长的平头

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

  三、字符串类型(String)

三.浮点型:就是带小数点的数字

贰.5 常用函数
#!/usr/bin/python3
# -*- coding: UTF-8 -*-

import base64

s = 'hello world !'

#  1.把字符串的第一个字符大写
print('s.capitalize():',s.capitalize())
#  2.返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
print('s.center(20):',s.center(20))
print('s.center(20,\'*\'):',s.center(20,'*'))
#  3.返回 str 在 string 里面出现的次数,如果 beg 或者 end 指定则返回指定范围内 str 出
#    现的次数
"""
参数1:搜索的子字符串;
参数2:字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0;
参数3:字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

"""
print('s.count(\'l\',0,-1):',s.count('l',0,-1))
#  4.以 encoding 指定的编码格式解码 string,如果出错默认报一个 ValueError 的异常,除非 
#    errors 指定的是 'ignore' 或者'replace'
"""
python3不太一样:因为3.x中字符都为unicode编码,而b64encode函数的参数为byte类型,所以必须先转码
"""
encodestr = base64.b64encode('abcr34r344r'.encode('utf-8'))
"""
1).encodestr: b'YWJjcjM0cjM0NHI='  结果和我们预想的有点区别,我们只想要获得YWJjcjM0cjM0NHI=
,而字符串被b''包围了。
2).b 表示 byte的意思,我们只要再将byte转换回去就好了
"""
print('encodestr:',encodestr)

encodestr1 = str(encodestr,'utf-8', errors='strict')
print('encodestr1:',encodestr1) #  encodestr1: YWJjcjM0cjM0NHI=

decodestr = base64.b64decode(encodestr1.encode('utf-8'))
print('decodestr:',decodestr)  #  b'abcr34r344r'
print(str(decodestr,'utf-8', errors='strict'))  #  abcr34r344r
#  5.检查字符串是否以 obj 结束,如果beg或者end指定则检查指定的范
#    围(长度)内是否以obj结束,如果是,返回 True,否则返回 False.
print('\'test\'.endswith(\'t\',4):','test'.endswith('t',0,4))
#  6.把字符串中的 tab 符号('\t')转为空格,tab 符号('\t')默认的空格数是 8。
#  this is        string example....wow!!!
print('this is\tstring example....wow!!!'.expandtabs(15))  
#  7.检测 str 是否包含在 string 中,如果 beg 和 end 指定范围,则检查是否包含在指定范
#    围内,如果是返回开始的索引值,否则返回-1
"""
str -- 指定检索的字符串
beg -- 开始索引,默认为0。
end -- 结束索引,默认为字符串的长度。
注意:检测到一个就会停止
"""
print(s.find('l',0,10))
#  8.跟find()方法一样,只不过如果str不在 string中会报一个异常
print('\'good\'.index(\'0\',0,4):','good'.index('o',0,4))
#  9.如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
#    (检测字符串是否由字母和数字组成)
print("'678'.isalnum():",'678'.isalnum())
print("'6a78'.isalnum():",'6a78'.isalnum())
print("'-he66'.isalnum():",'-he66'.isalnum())
#  10.如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False(检测字
#     符串是否只由字母组成)
print("'678'.isalpha():",'678'.isalpha())
print("'6a78'.isalpha():",'6a78'.isalpha())
print("'gegge'.isalpha():",'gegge'.isalpha())
#  11.如果 string 只包含十进制数字则返回 True 否则返回 False)
#     注意:定义一个十进制字符串,只需要在字符串前添加 'u' 前缀即可。
print("'678'.isdecimal():",'678'.isdecimal())
print("'678a'.isdecimal():",'678a'.isdecimal())
print("'0x124ad'.isdecimal():",'0x124ad'.isdecimal())
#  12.如果 string 只包含数字则返回 True 否则返回 False.
print("'678'.isdigit():",'678'.isdigit())
print("'678t'.isdigit():",'678t'.isdigit())
#  13.如果 string 中只包含数字字符,则返回 True,否则返回 False
print("'678'.isnumeric():",'678'.isnumeric())
print("'678t'.isnumeric():",'678t'.isnumeric())
#  14.如果 string 中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是
#     小写,则返回 True,否则返回 False(检测字符串是否由小写字母组成)
print("'test'.islower():",'test'.islower())
print("'Test'.islower():",'Test'.islower())
#  15.如果 string 中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是大
#     写,则返回 True,否则返回 False
print("'test'.isupper():",'test'.isupper())
print("'TEST'.isupper():",'TEST'.isupper())
#  16.如果 string 中只包含空格,则返回 True,否则返回 False
print("'       '.isspace():",'       '.isspace())
print("'This is string example....wow!!!'.isspace():",
'This is string example....wow!!!'.isspace())
#  17.如果 string 是标题化的(见 title())则返回 True,否则返回 False
print("'This Is A Test'.istitle():",'This Is A Test'.istitle())
print("'This is a test'.istitle():",'This is a test'.istitle())
#  18.以 string 作为分隔符,将 seq 中所有的元素(的字符串表示)合并为一个新的字符串(将序
#     列中的元素以指定的字符连接生成一个新的字符串)
seq = ("r", "u", "n", "o", "o", "b") # 字符串序列
print ("'-'.join(seq):",'-'.join(seq))
print ("''.join(seq):",''.join(seq))
#  19.len() 方法返回对象(字符、列表、元组等)长度或项目个数
print("len('hello'):", len('hello'))
#  20.返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
print("'hello'.ljust(20,'*'):", 'hello'.ljust(20,'*'))
#  21.转换 string 中所有大写字符为小写
print("'HELLO'.lower():", 'HELLO'.lower())
#  22.转换 string 中的小写字母为大写
print("'hello'.upper():", 'hello'.upper())
#  23.截掉 string 左边的字符
print("'  hello'.lstrip(' '):", '  hello'.lstrip(' '))
print("'88888hello'.lstrip(' '):", '  hello'.lstrip('8'))
#  24.maketrans() 方法用于创建字符映射的转换表,对于接受两个参数的最简单的调用方式,
# 第一个参数是字符串,表示需要转换的字符,第二个参数也是字符串表示转换的目标
"""
maketrans() 方法用于创建字符映射的转换表,对于接受两个参数的最简单的调用方式,
第一个参数是字符串,表示需要转换的字符;
第二个参数也是字符串表示转换的目标。
两个字符串的长度必须相同,为一一对应的关系。
注:Python3.4已经没有string.maketrans()了,取而代之的是内建
函数: bytearray.maketrans()、bytes.maketrans()、str.maketrans()
"""
#  以下实例展示了使用maketrans() 方法将所有元音字母转换为指定的数字
intab = "aeiou"
outtab = "12345"
trantab = str.maketrans(intab, outtab)
str = "this is string example....wow!!!"
print (str.translate(trantab))
#  25.返回字符串 str 中最大的字母
print("max('abjzkqp'):", max('abjzkqp'))
#  26.返回字符串 str 中最小的字母
print("min('abjzkqp'):", min('abjzkqp'))
#  27.返回长度为 width 的字符串,原字符串 string 右对齐,前面填充0
print("'world'.zfill(20):", 'world'.zfill(20))
#  28.翻转 string 中的大小写
print("'WorLd'.swapcase():", 'WorLd'.swapcase())
#  29.返回"标题化"的 string,就是说所有单词都是以大写开始,其余字母均为小写(见 istitle())
print("'this is a test'.title():", 'this is a test'.title())
#  30.把 string 中的 str1 替换成 str2,如果 num 指定,则替换不超过 num 次.
print("'this is a test'.replace('s','q',3):", 'this is a test'.replace('s','q',3))
#  31.类似于find()函数,不过是从右边开始查找(返回字符串最后一次出现的位置,如果没有匹配项则
#     返回-1)
"""
str -- 查找的字符串
beg -- 开始查找的位置,默认为0
end -- 结束查找位置,默认为字符串的长度。
"""
print("'hello'.rfind('l',0,5):", 'hello'.rfind('l',0,5))
#  32.类似于index(),不过是从右边开始(返回子字符串str在字符串中最后出现的位置,如果没有匹配的
#     字符串会报异常)
print("'hello'.rindex('l',0,5):", 'hello'.rindex('l',0,5))
#  33.返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
print("'test'.rjust(20,'*'):", 'test'.rjust(20,'*'))
#  34.删除 string 字符串末尾的指定字符(默认为空格)
print("'world*****'.rstrip('*'):", 'world*****'.rstrip('*'))
#  35.在string上执行lstrip()和rstrip()(用于移除字符串头尾指定的字符(默认为空格))
print("'***test***'.strip('*'):", '***test***'.strip('*'))
#  36.根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中
"""
able -- 翻译表,翻译表是通过 maketrans() 方法转换而来。
deletechars -- 字符串中要过滤的字符列表。
"""
bytes_tabtrans = bytes.maketrans(b'abcdefghijklmnopqrstuvwxyz', 
b'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
print(b'runoob'.translate(bytes_tabtrans, b'o'))  # 转换为大写,并删除字母o
#  37.检查字符串是否是以obj开头,是则返回True,否则返回False。如果beg和end 指定值,则在指定范
#     围内检查
print("'test'.startswith('t',0,4):", 'test'.startswith('t',0,4))
#  38.以 str 为分隔符切片 string,如果 num有指定值,则仅分隔 num 个子字符串
"""
str -- 分隔符,默认为所有的空字符,包括空格、换行(\n)、制表符(\t)等。
num -- 分割次数。
"""
str = "this is string example....wow!!!"
print(str.split( ))  #  ['this', 'is', 'string', 'example....wow!!!']
print(str.split('i',1))  #  ['th', 's is string example....wow!!!']
print(str.split('w'))  #  ['this is string example....', 'o', '!!!']
#  39.按照行('\r', '\r\n', \n')分隔,返回一个包含各行作为元素的列表,
#     如果参数 keepends 为 False,不包含换行符,如果为 True,则保留换行符
#  ['ab c', '', 'de fg', 'kl']
print('ab c\n\nde fg\rkl\r\n'.splitlines())  
#  ['ab c\n', '\n', 'de fg\r', 'kl\r\n']
print('ab c\n\nde fg\rkl\r\n'.splitlines(True))  
#  40.有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把字
#     符串string分成一个3元素的元组 (string_pre_str,str,string_post_str)
#     ,如果 string 中不包含str 则 string_pre_str == string.
#     根据指定的分隔符将字符串进行分割
"""
如果字符串包含指定的分隔符,则返回一个3元的元组,第一个为分隔符左边的子串,
第二个为分隔符本身,第三个为分隔符右边的子串
"""
str6 = "https://www.baidu.com/"
print(str6.partition("://"))
#  41.类似于 partition()函数,不过是从右边开始查找
print(str6.rpartition("://"))

    字符串嘛,就是各类字符的组成,绝对于计算机来讲,字符串是比较直观的,能够很轻易转化为ASCLL码,然后编制程序贰进制,接着汇编,转化学工业机械器指令…。

4.布尔型:True与False(1和0)

三.空值(None)。

空值是Python里一个出奇的值,用None表示。None不能够明了为0,因为0是有意义的,而None是一个奇特的空值。

  

伍.复数:
复数有实数部分和虚数部分组成,一般方式为x+yj,个中x是复数的实数部分,y是复数的虚数部分,这里的x和y都以实数。

4. List(列表:有序可变)

  • List(列表) 是 Python
    中央银行使最频仍的数据类型。与Objective-C中的NSMutableArray类似。
  • 列表能够成功大繁多集结类的数据结构落成。列表瓜月素的品类可以差异样,它援助数字,字符串乃至足以包括列表(所谓嵌套)。
  • 列表是写在方括号([])之间、用逗号分隔离的成分列表。
  • 和字符串同样,列表同样能够被索引和截取,列表被截取后重返一个饱含所需成分的新列表。

  4、列表类型(List)

留意,虚数的深浅写字部分的字母j不分大小写

4.1 创立列表:
# 方法一:
ame_list = ['alex', 'seven', 'eric']
# 方法二:
name_list = list(['alex', 'seven', 'eric'])

    列表是由众多组字符串组成的成团(个人见解)。

图片 2

四.贰 常用函数:
#!/usr/bin/python3
# -*- coding: UTF-8 -*-

import copy

a = 89
b = '6'
ame_list = [68, 68, 58, 108945, 1, 75, 69] # 列表1
temp_list = [55, 75, 452, 7856, 4553, 45354, 54] # 列表2
temp_list1 = ['b','y','q','a','k','z','p','b' ] # 列表3
tup1 = ('Google', 'Runoob', 1997, 2000) # 元组

# 1.列表元素个数
print(len(ame_list))
# 2.返回列表元素最大值
print(max(ame_list))
# 3.返回列表元素最小值
print(min(ame_list))
# 4.将元组转换为列表
print(list(tup1))
# 5.在列表末尾添加新的对象
ame_list.append(a)
print(ame_list)
# 6.统计某个元素在列表中出现的次数
print(ame_list.count(68))
# 7.在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
(ame_list.extend(temp_list))
print(ame_list)
# 8.从列表中找出某个值第一个匹配项的索引位置
print(ame_list.index(1,0,6)) # 参数:value,起始位置,结束位置
print(ame_list.index(75))  # 无起始值则遍历所有value
# 9.将对象插入列表
'''
共有如下5种场景:
场景1:index=0时,从头部插入obj
场景2:index > 0 且 index < len(list)时,在index的位置插入obj
场景3:当index < 0 且 abs(index) < len(list)时,从中间插入obj,
      如: -1 表示从倒数第1位插入obj; -2 表示从倒数第2位插入obj
场景4:当index < 0 且 abs(index) >= len(list)时,从头部插入obj
场景5:当index >= len(list)时,从尾部插入obj
'''
ame_list.insert(2,198) # 参数:插入位置,插入值
print(ame_list)
# 10.移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
print(ame_list.pop(-1)) # -1代表最后一个元素
print(ame_list)
# 11.移除列表中某个值的第一个匹配项
ame_list.remove(68)
print(ame_list)
# 12.反向列表中元素
ame_list.reverse()
print(ame_list)
# 13.对原列表进行排序 list.sort([func])
ame_list.sort() # func 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
print(ame_list)
# 14.复制列表( copy() 函数用于复制列表,类似于 a[:])。
new_list1 = copy.copy(temp_list1) # 要导入copy类import copy
new_list2 = copy.deepcopy(temp_list1)
print(new_list1)
print(new_list2)
# 15.清空列表 (clear() 函数用于清空列表,类似于 del a[:]。)
new_list2.clear() # clear()函数3.x以上版本才有,2.x无
print(new_list2)

  

陆.生出数字的办法

5. Tuple(元组:有序不可变)

不足变列表类似Objective-C中的NSArray,开始化如下:

#!/usr/bin/python3
# -*- coding: UTF-8 -*-
# 方法一:
ages = (11, 22, 33, 44, 55)
# 方法二:
ages = tuple((11, 22, 33, 44, 55))

  5、元组类型(Tuple)

1 # age=18
2 # age1=int(18)
3 # print (age,type(18))
4 # print (age1,type(18))       #整数
5 
6 # salay=3000.00
7 # salay1=float(3000.00)
8 # print (salay,type(3000.00))       #浮点型
9 # print(salay1,type(3000.00))
伍.一 访问元组
#!/usr/bin/python3

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )

print ("tup1[0]: ", tup1[0])  # tup1[0]:  Google
print ("tup2[1:5]: ", tup2[1:5])  # tup2[1:5]:  (2, 3, 4, 5)

    元组是Python中不可变类型(就算字符、常量等还有不少也是,至于何以是不足变类型,后边再写吗。),当然,以后说的元组不可变是指元组内的要素不可改换(特殊情势除此而外,不是不足变类型中的不可变)。

二 字符串

五.2 删除元组

元组中的成分值是不容许删除的,但大家能够利用del语句来删除全部元组

#!/usr/bin/python3

tup = ('Google', 'Runoob', 1997, 2000)
print (tup)
del tup;
print ("删除后的元组 tup : ")
print (tup) # 以上实例元组被删除后,输出变量会有异常信息,输出如下所示:
"""
('Google', 'Runoob', 1997, 2000)
Traceback (most recent call last):
删除后的元组 tup : 
  File "/Users/ysf/Desktop/Python/package1/LYDictionary.py", line 11, in <module>
    print (tup) # 以上实例元组被删除后,输出变量会有异常信息,输出如下所示:
NameError: name 'tup' is not defined
"""

  

在python如何定义一串字符为字符串呢?

5.3 注意点
  • 只顾点一:

# 但是,要定义一个只有1个元素的tuple,如果你这么定义:
>>> t = (1)
>>> t
# 输出结果是:1
""" 
定义的不是tuple,是1这个数!这是因为括号()既可以表示tuple,又可以表示数学公式中的小括号,这就产
生了歧义,因此,Python规定,这种情况下,按小括号进行计算,计算结果自然是1。所以,只有1个元素的
tuple定义时必须加一个逗号(,)来消除歧义:
"""
>>> t = (1,)
>>> t
# 输出结果是:(1,)
  • 注意点2:“可变的”tuple:

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
# 输出结果是:('a', 'b', ['X', 'Y'])
"""
这个tuple定义的时候有3个元素,分别是'a','b'和一个list。不是说tuple一旦定义后就不可变了吗?怎么
后来又变了?表面上看,tuple的元素确实变了,但其实变的不是tuple的元素,而是list的元素。tuple一开
始指向的list并没有改成别的list,所以,tuple所谓的“不变”是说,tuple的每个元素,指向永远不变。即
指向'a',就不能改成指向'b',指向一个list,就不能改成指向其他对象,但指向的这个list本身是可变的!
所以说要创建一个内容也不变的tuple,那就必须保证tuple的每一个元素本身也不能变。
"""

图片 3

  陆、字典类型(Dictionary)

  用 ” ” 、’ ‘ 、”’ ”’也许””” “””。中间含有的部分称作字符串

陆. Dictionary(字典可变)

字典是另1种可变容器模型,且可存款和储蓄大四档期的顺序对象,在其余语言中也称之为map,使用键-值(key-value)存储,具备十分的快的找出速度。字典的每一个键值(key=>value)对用冒号(:)分割,各类对里面用逗号(,)分割,整个字典包蕴在花括号({})中
,格式如下所示:

d = {key1 : value1, key2 : value2 }

    字典由键(key)和值(value)组成,就像是其名字,能够像查字典同样,依照key查找value。

    PS:尽管其中写入的是数字,那么她的数据类型也是字符串

陆.一 dict的完成原理

为何dict查找速度如此快?因为dict的兑现原理和查字典是同一的。假使字典包蕴了叁万个汉字,大家要查某3个字,3个措施是把字典从第三页今后翻,直到找到大家想要的字结束,这种艺术便是在list中探究成分的方法,list越大,查找越慢。

其次种方法是先在字典的目录表里(举例部首表)查这几个字对应的页码,然后径直翻到该页,找到这么些字。无论找哪个字,那种查找速度都不行快,不会趁机字典大小的增添而变慢。

dict正是第几种完毕方式,给定贰个名字,举个例子’迈克尔’,dict在里面就能够直接总结出迈克尔对应的寄放成绩的“页码”,也正是九伍以此数字存放的内部存款和储蓄器地址,直接抽出来,所以速度相当的慢。那种key-value存款和储蓄格局,在放进去的时候,必须依附key算出value的寄放地点,那样,取的时候手艺凭仗key间接获得value。

  

例如name=’Chares_Lee’

陆.二 特性及常用函数
  • 键必须是独占鳌头的,但值则不供给。
  • 值可以取任何数据类型,但键必须是不可变的,如字符串,数字或元组。(键必须不可变,所以能够用数字,字符串或元组充当,而用列表就卓殊)
  • 多个key只好对应1个value,所未来往对贰个key放入value,前边的值会把前边的值覆盖
  • 假如key不设有,dict就能够报错

#!/usr/bin/python3
# -*- coding: UTF-8 -*-


# 1.字典初始化
dict1 = {'name': 'sam', 98.6: 37, 'sex': '男', 'height': 188, 'car': '路虎'}
dict2 = {'name': 'sam', 98.6: 37, 'sex': '男', 'height': 188}
print("dict1: ", dict1)
# 2.访问字典里的值
print("dict1['name']: ", dict1['name'])
# 3.避免key不存在的错误,有两种办法,一是通过in判断key是否存在;二是通过dict提供的get()方法,如
#果key不存在,可以返回None,或者自己指定的value:
print("age in dict1: ", 'age' in dict1)  # 方法一
print("age in dict1: ", dict1.get('age'))  # 方法二  默认值为None
print("age in dict1: ", dict1.get('age', -1))  # 方法二  自定义value
# 4.和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default
print("dict1.setdefault: ", dict1.setdefault('Taobao', '淘宝'))
# 5.删除一个key
print("dict1.pop('name'): ", dict1.pop('name'))
print("dict1: ", dict1)
# 6.计算字典元素个数,即键的总数。
print("len(dict1): ", len(dict1))
# 7.输出字典,以可打印的字符串表示。
print("str(dict1): ", str(dict1))
# 8.返回输入的变量类型,如果变量是字典就返回字典类型。
print("type(dict1): ", type(dict1))  # <class 'dict'>
# 9.删除字典内所有元素
dict2.clear()
print("dict2: ", dict2)
# 10.返回一个字典的浅复制
print("dict1.copy(): ", dict1.copy())
# 11.以列表返回可遍历的(键, 值)元组数组
print("dict1.items(): ", dict1.items())
# 12.以列表返回一个字典所有的键
print("dict1.keys(): ", dict1.keys())
# 13.以列表返回字典中的所有值
print("dict1.values(): ", dict1.values())
# 14.把字典dict1的键/值对更新到dict2里
dict2.update(dict1)
print("dict2.update(dict1)后dict2的值: ", dict2)
# 15.删除字典给定键 key 所对应的值,返回值为被删除的值。key值必须给出。 否则,返回default值。
dict1.pop('car')
print("dict1: ", dict1)
# 16.随机返回并删除字典中的一对键和值(一般删除末尾对)。
dict2.popitem()
print("dict2: ", dict2)
# 17.创建一个新字典,以序列seq中元素做字典的键,val为字典所有键对应的初始值
seq = ('name', 'age', 'sex')
dict3 = dict.fromkeys(seq)
print("新的字典为 : %s", str(dict3))   # 全部key的value都默认赋值为:None
dict4 = dict.fromkeys(seq, 10)   # 全部key的value都赋值为:10
print("新的字典全部key的value都赋值为:10 : %s",  str(dict4))

# 18.键用列表会报错
dict5 = {['Name']: 'Runoob','Age': 7}
"""
Traceback (most recent call last):
  File "/Users/ysf/Desktop/Python/package1/LYDictionary.py", line 30, in <module>
    dict = {['Name']: 'Runoob',  'Age': 7}
TypeError: unhashable type: 'list'
"""

# 19.如果用字典里没有的键访问数据,会输出错误
print("dict1['job']: ", dict1['job'])
"""
Traceback (most recent call last):
  File "/Users/ysf/Desktop/Python/package1/LYDictionary.py", line 63, in <module>
    print("dict1['job']: ", dict1['job'])
KeyError: 'job'
"""

  7、集合(set)

  在’ ‘里面包车型客车正是字符串

陆.3 dict和list的利害

和list比较,dict有以下多少个本性:

  • 寻觅和插入的速度相当慢,不会趁着key的增添而变慢;
  • 必要占用大批量的内部存款和储蓄器,内部存款和储蓄器浪费多。

list优缺点:

  • 检索和插入的小时随着成分的增加而扩大;
  • 占用空间小,浪费内部存款和储蓄器很少。

总结:据此,dict是用空间来换取时间的壹种方式。dict能够用在要求飞快查找的很多地点,在Python代码中大概无处不在,正确使用dict分外重大,要求记住的率先条就是dict的key必须是不可变对象

这是因为dict依据key来计量value的囤积地点,借使每趟计算同1的key得出的结果分化,那dict内部就完全混乱了。这么些经过key总括地方的算法称为哈希算法(Hash)。要确认保证hash的正确,作为key的目的就不可能变。在Python中,字符串、整数等都以不可变的,由此,能够放心地看成key。而list是可变的,就不可能作为key:

    图里面未有写上,因为本人以为那么些大家都懂!!!(~ V
~)!!!,直到未来作者发觉的唯1的用处正是去重!去重!去重! 
重要的政工说一遍,真不知道为啥就为了那三天个性去造这么二个类型.

1 使用三引号 ('''或""")
2 利用三引号 你可以指示一个多行的字符串 你可以在三引号中自由的使用单引号和双引号 例如
3 ''' This is a multi-line string. This is the first line.
4     This is the second line.
5     "What is your name?" I asked.
6     He said "Chares Lee."
7 '''

7. Set(冬辰不重复成分集结)

set和dict类似,也是壹组key的聚众,但不存款和储蓄value。由于key不能够重复,所以,在set中,未有再一次的key。总计:set和dict的并世无双差异仅在于未有存款和储蓄对应的value

 

 注意字符串是不可改造的

7.1 Set特性
  • 聚拢(set)是1个严节不另行成分的队列。
  • 基本功效是开始展览成员涉及测试和删除重复成分。
  • 能够使用大括号 { } 或者 set()
    函数创立集结,注意:创制七个空集结必须用set()而不是 { },因为
    { }是用来创立三个空字典。

   好了,临时就写那样多了,毕竟作者是个懒胖子,写10分都会格外的pang技术员。

发出字符串的法门

7.2 创建Set
# 方法一:
parame = {value01,value02,...}
# 方法二:
set(value)
1 # test='hello'
2 # test1=str('hello')
3 # print (test,type(test))           #字符串
4 # print (test1,type(test1))
七.3 基本用法
#!/usr/bin/python3
# -*- coding: UTF-8 -*-

# 1.创建一个set,需要提供一个list作为输入集合,重复元素在set中自动被过滤
s = set([1, 1, 2, 2, 3, 3])  # {1, 2, 3}
# 2.通过add(key)方法可以添加元素到set中,可以重复添加,但只有第一次有效果
s.add(4)  # {1, 2, 3, 4}
s.add(4)  # {1, 2, 3, 4}
# 3.通过remove(key)方法可以删除元素
s.remove(4)  # {1, 2, 3},不能移除不存在的key
# 4.set可以看成数学意义上的无序和无重复元素的集合,因此,两个set可以做数学意义上的交集、并集
# 等操作:
s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
print("s1 & s2: ", s1 & s2)  # {2, 3}
print("s1 | s2: ", s1 | s2)  # {1, 2, 3, 4}

科学普及的字符串操作有:

  移除空白、分隔、长度、索引、切丝、(详细情形请参考:Python第一天——入门Python(2)字符串的简单操作)

三.列表

  []内以逗号分隔,依据索引,存放种种数据类型,每一种地点代表一个因素

概念列表

1 # l=[1,2,3,4]
2 # l1=list([1,2,3,4])
3 # l2=list('1234')
4 # print (l,type(l))
5 # print (l1,type(l1))
6 # print (l2,type(l2))     #列表的定义方法

广大的列表操作有:

  扩展、插入、删除、查询、切成块、索引、长度等(详细情况请参考:Python第一天——入门Python(3)列表)

四、元组

  以'()’圆括号举办定义,与列表极其相似。也是系列类型
能够实行索引,切条,查询,也得以开始展览遍历

1 # test=(1,2,3,4)
2 
3 # for i in test:        #元组的遍历方法
4 
5 #     print(i)

元组与列表的并世无双差异则是不行更换

分布操作

1 # test=(1,2,3,4,4,4)
2 # print (test.count(4))       #查看元组中的某个元素的个数
3 
4 # test=(1,2,3,4)
5 # print (test.index(4))         #查看元组中某个元素的下标
5 # print (len(test))        #查看元组的长度
6
7 # print (1 in test)        #包含

索引、切片、循环、长度、包含

五、字典

字典占用的内部存款和储蓄器空间将会压倒列表,在系统中要保存3个hash列表(用系统内存换取时间)

字典属于key:value 结合(key值是不可变的,value值能够变)并且是九冬的

留神:字典是冬季排列的 

1 #
dic=dict(nama=’lhc’,age=23)

2 # print
(dic) #开创字典 

详见操作请参见:Python第3天——入门Python(四)字典的常用操作

集合(工厂函数)

概念:由不相同的要素结合的集结,集结中是一组冬日排列的可hash值,可作为字典的key,而且集结中的值不得重复。

天性:会集的目标就是将差别的值存放在一起,差异的集聚间来做涉嫌运算,冬季纠结集结中单个值

汇集包蕴可变集结和不可变集合

hash是什么?

打个比如,举例说有三个文本(不管多大),对那么些文件要实行一个hash校验,会获得2个校验值(固定长度)。

hash是一种统称,具体要拓展校验的话,是急需调用它下边包车型地铁算法。(校验正是通过三个算法算出这一个文件的二个值)。

特点:

  壹.比如用的算法是迟早,那么得到的值的长度恒久是早晚的

  贰.原值(被校验的值)只要改一点,那么在此校验的值将会变动

  3.不可逆。不容许通过1串hash值来演绎出这么些文件内容

算法:MD5 SH512等等

用途:最多的用途正是进文件校验(看文件是不是被歪曲)。再一个正是tcp/ip协议。只可以对不可变的值举办hash校验。假如群集中有可变类型那么回保错。

图片 4图片 5

s={1,'a',[1,2,3],'a'}
print(s)

Traceback (most recent call last):
  File "C:/Users/Administrator/PycharmProjects/untitled/day9/集合.py", line 4, in <module>
    s={1,'a',[1,2,3],'a'}
TypeError: unhashable type: 'list'

e,g

说列表是不可hash类型

在python中,看到不可hash类型正是可变类型,反之,可hash类型正是不行变类型

去重

s={1,'a','a'}
print(s)

{'a', 1}

无序

s={1,'a',(1,2,3),}
print(s)

{'a', 1, (1, 2, 3)}

能够运用迭代器取值

详细操作请参见

变量

  什么是变量?

  通过字面包车型客车意趣明白为变化的量。具体解释为:保存处境(程序的运转本质是1雨后冬笋情景的转移,变量的目标正是用来保存意况,变量的值得变化就钩子程序运维的例外结果)

  比方:LOL的职员,每一种人都有些的血量,当血量大于零的时候表示life=active活着,当满意血量等于零的时候修改造量为life=inactive,表示驾鹤归西。

  变量的命名标准

  变量的第二个字符必须是字母表中的字母(大写或小写)也许2个下划线(‘ _’)。

  变量名称的其余一些能够由字母(大写或小写)、下划线(‘ _ ’)或数字(0-9)组成。

  变量名称是对大小写敏感的 举个例子 myname和myName不是三个标记符

  有效的变量名称例子 i、_my_name name_23和 abl2_c3

  无效的变量有贰things this is spaced 和my-name

中国共产党第五次全国代表大会数据类型基本划分:

安份守己存款和储蓄数据个数分别

标量/原子类型(值能存放一个值) 数字,字符串                            
容器类型(存放多个值) 列表,元组,字典

 

 

 

遵照可变不可变区分

可变类型指的是在同样块内存地址之上能够将值替换掉(使用id()函数查看变量的内部存款和储蓄器地址)

可变                      列表,字典
不可变 数字,字符串,元组

 

 

 

根据访问顺序分别

直接访问(不可拆分) 数字
顺序访问(有下标的) 字符串,元组,列表      
key值访问(映射类型) 字典   

 

 

 

数据结构

数据结构的意义:将上述中国共产党第五次全国代表大会数据类型整合到一块儿。不过掺到3只不是目标。目的是力所能致组合成3个好的组织,方便自个儿或然别人举行多少存款和储蓄大概读取。

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图