第二篇:python基础语法与基本数据类型

时间:2022-12-21 15:10:40

    上一篇我们已经简单了解了python的介绍。在继续之前,需要刚入门的朋友注意一点,以后所提供的练习案例的代码,除了你已掌握相关知识点,请千万不要用“复制”-“粘贴”把代码从页面粘贴到你自己 的电脑上。写程序也讲究一个感觉,你需要一个字母一个字母地把代码 自己敲进去,在敲代码的过程中,初学者经常会敲错代码,所以,你需 要仔细地检查、对照,才能以最快的速度掌握如何写程序。Python 是一种计算机编程语言。计算机编程语言和我们日常使用的自然 语言有所不同,最大的区别就是,自然语言在不同的语境下有不同的理 解,而计算机要根据编程语言执行任务,就必须保证编程语言写出的程 序决不能有歧义,所以,任何一种编程语言都有自己的一套语法,编译 器或者解释器就是负责把符合语法的程序代码转换成 CPU 能够执行的 机器码,然后执行。Python 也不例外。

 

注释与缩进

    Python 的语法比较简单,采用缩进方式。以#开头的语句或三重引号包含的内容(也称文档字符串)是注释,注释是给人看的,可以是任意内容,解释器会 忽略掉注释。其他每一行都是一个语句,当语句以冒号:结尾时,需要缩进,否则报错。,缩进 的语句视为代码块。Python 函数没有明确的开始(begin)或者结束(end),也没 有用大括号来标记函数从哪里开始从哪里停止。唯一的定界符 就是一个冒号(:)和代码自身的缩进。python是以强制缩进方式格式化代码,使得python代码变得简洁明了。缩进有利有弊。好处是强迫你写出格式化的代码,但没有规定缩进是几 个空格还是 Tab。按照约定俗成的管理,应该始终坚持使用 4 个空格的 缩进。缩进的坏处就是“复制-粘贴”功能失效了,这是最坑爹的地方。当你重 构代码时,粘贴过去的代码必须重新检查缩进是否正确。通常在 Python 中, 默认以换行为新的一行,若想在一行输入多句语句,一定要加‘ ;’ ,否则报错。最后,请务必注意,Python 程序是大小写敏感的,如果写错了大小写, 程序会报错(如变量命名为“Number”,调用时不能使用“number”调用。

 

#python代码语法实例
num = 1; num2 = 6 #用‘;'隔开一行中的多个语句
if num > 0:
    # 以:结尾的语句下的缩进代码块属于此语句的子代码。
    num3 = 3
    print(num+num2)
print(num); print(num3)

词法元素

   语言中的词法元素是用于构造语句一类的单词和符号。和所有语的高级语言一样,python的一些基本符号是关键字,例如,if、while、def、class等,还包括了其他一些词法元素,例如,标识符(名称)、字面值(数字、字符串、和其他内建的数据类型)、运算符、分隔符(引号、逗号、圆括号、方括号和大括号)。

 

语法元素

  一种语言的语法元素是由词法元素组成的语句(表达式、语句和其他结构)。和其他高级语言不同,python采用空格、换行和缩进来标记多种类型的语句的语法。这意味着,在python中换行和缩进是很重要的。

 

标识符

  标识符是自己定义的 , 如变量名 、函数名,类名等。

  标识符命名规则:

    1 、只能包含字母、数字和下划线。变量名可以以字母或者下划线开头。但 是不能以数字开头。

    2 、不能包含空格,但可以使用下划线来分隔其中的单词。

    3 、不能使用 Python 中的关键字作为变量名。

    4 、建议使用驼峰命名法,驼峰式命名分为大驼峰( UserName )。和小驼 峰( userName )。

    python中的一些关键字:

      第二篇:python基础语法与基本数据类型

   命名惯例:模块、变量、函数的名称,都是首字母小写的驼峰命名法,类名是首字母大写的驼峰命名法,当变量是常量的时候,其所有字母都是大写的,并且会有一个下划线用来隔开任何嵌入的单词。

 

变量和赋值语句

   变量在程序中就是用一个变量名表示了,变量名必须是大小写英文、数 字和_的组合,且不能用数字开头。python中的变量采用引用语义,每一个变量名其实存储的是实际存放数据的内存的地址。我们可以理解为所有的变量全部都是引用类型,等号=是赋值语句,把对象地址引用给变量,可以把任意数据类型赋值给变量,同 一个变量可以反复赋值,而且可以是不同类型的变量。比如a=A(),首先python创建一个对象A,然后声明一个变量a,再将变量a与对象A联系起来。变量a是没有类型的,它的类型取决于其关联的对象。a=A()时,a是一个A类型的引用,我们可以说a是A类型的,如果再将a赋值3,a=3,此时a就是一个整型的引用。这种变量本身类型不固定的语言称之为动态语言,与之对应的是静态语 言。静态语言在定义变量时必须指定变量类型,如果赋值的时候类型不 匹配,就会报错。例如 Java 是静态语言,赋值语句如下(// 表示注释):int a = 123; // a 是整数类型变量,a = "ABC"; // 错误:不能把字符串赋给整型变量,和静态语言相比,动态语言更灵活。请不要把赋值语句的等号等同于数学的等号。比如下面的代码:

x = 10
x = x + 2
print(x)
'''如果从数学上理解 x = x + 2 那无论如何是不成立的,在程序中,赋值
语句先计算右侧的表达式 x + 2,得到结果 12,再赋给变量 x。由于 x
之前的值是 10,重新赋值后,x 的值变成 12'''

 

最后,理解变量在计算机内存中的表示也非常重要。当我们写:a = 'ABC' 时,Python 解释器干了两件事情:1. 在内存中创建了一个'ABC'的字符串; 2. 在内存中创建了一个名为 a 的变量,并把它指向'ABC'。也可以把一个变量 a 赋值给另一个变量 b,这个操作实际上是把变量 b 指向变量 a 所指向的数据,例如下面的代码:

a = 'ABC'
b = a
a = 'XYZ'
print(b)
'''最后一行打印出变量 b 的内容到底是'ABC'呢还是'XYZ'?如果从数学意 义上理解,就会错误地得出 b 和 a 相同,也应该是'XYZ',但实际上 b 的 值是'ABC','''

让我们一行一行地执行代码,就可以看到到底发生了什么事,执行 a = 'ABC',解释器创建了字符串'ABC'和变量 a,并把 a 指向'ABC':

第二篇:python基础语法与基本数据类型

执行 b = a,解释器创建了变量 b,并把 b 指向 a 指向的字符串'ABC':

第二篇:python基础语法与基本数据类型

执行 a = 'XYZ',解释器创建了字符串'XYZ',并把 a 的指向改为'XYZ', 但 b 并没有更改:

 第二篇:python基础语法与基本数据类型

所以,最后打印变量 b 的结果自然是'ABC'了。

 

常量

  所谓常量就是不能变的变量,比如常用的数学常数 π 就是一个常量。在 Python 中,通常用全部大写的变量名表示常量: PI = 3.14159265359 但事实上 PI 仍然是一个变量,Python 根本没有任何机制保证 PI 不会被 改变,所以,用全部大写的变量名表示常量只是一个习惯上的用法,如 果你一定要改变变量 PI 的值,也没人能拦住你。当一个对象没有被赋值给变量而被调用,也可视为一个常量,如: print(3.14159265359),此时3.14156265359可视为常量。

 

输入和输出

  输出

  print()函数用来接受各种数据类型,并以字符串形式将数据类型的可视信息输出到控制台。在python中可用help()函数传入函数名查看函数的相关参数与函数文档。

help(print)

'''
运行结果:

Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.
'''

print('mm='     'sdsdsdsd') #两字符串之间,无论隔了多少个空格,都视为没有空格。

  输入

  input()是python的输入函数,通过它能够完成从键盘获取数据,然后以字符串的方式保存到指定的变量中。即输入的是数字,那么也是以字符串的方式保存。这个函数接受一个可选字符串,并且会不换行的打印出这个字符串,以提示用户进行输入。

example = input('请输入一个数字:')
print(type(example)) #type()函数可查看对象所属数据类型

 

字面值 

  字面值是在程序里数据类型书写的表现形式,如数字在程序与数学的书写是一样的,字符串的表现形式是以引号把内容括起来。

 

基本数据类型

  计算机顾名思义就是可以做数学计算的机器,因此,计算机程序理所当 然地可以处理各种数值。但是,计算机能处理的远不止数值,还可以处 理文本、图形、音频、视频、网页等各种各样的数据,不同的数据,需 要定义不同的数据类型。,Python 提供了字符串、列表、字典等多种数据类型,还允许创建自定义 数据类型,python中常用的内置数据类型主要有以 下几种:

第二篇:python基础语法与基本数据类型

 

  Number

 

'''
int(x, base=10)方法:将浮点数或满足isalnum()方法的字符串转为十进制整形,
                    可选参数base用来指明x是什么进制数。默认值为10。
'''
num1 = 8.9
num2 = '3t'
num3 = '6f'
num4 = '8.9'
num5 = int(float(num4)) #若将小数字符串转为整型,必须先把它转为浮点型,否则报错。
print('num1整形前:',num1,'    num1整形后',int(num1))
print('num1整形前:',num2,'    num1整形后',int(num2,base=32))
print('num1整形前:',num3,'    num1整形后',int(num3,base=16))
print('num1整形前:',num4,'    num1整形后',num5)

'''
运行结果:
        num1整形前: 8.9     num1整形后 8
        num1整形前: 3t     num1整形后 125
        num1整形前: 6f     num1整形后 111
        num1整形前: 8.9     num1整形后 8
'''

'''
bit_length():返回十进制整型转二进制至少需要多少位二进制位数。
'''
int1 = 32
binary_number = bin(int1)  #将十进制转为二进制,表现形式以0b开头。
octonary_number = oct(int1)  #将十进制转为八进制,表现形式以0o开头。
hexadecimal_number = hex(int1)  #将十进制转为十六进制,表现形式以0x开头。
print('int1的转二进制数等于:', binary_number)
print('int1的二进制位数:', int1.bit_length())
print('int1的转八进制数等于:',octonary_number)
print('int1的转十六进制数等于:',hexadecimal_number)

'''
运行结果:
        int1的转二进制数等于: 0b100000
        int1的二进制位数: 6
        int1的转八进制数等于: 0o40
        int1的转十六进制数等于: 0x20
'''

 

  字符串

  字符串就是一系列任意文本。字符串是不可变的,也就说,一旦创建了字符串,不能更改其内部的内容。 Python 中的字符串用单引 号或者双引号括起来,同时可以使用反斜杠( \ )转义特殊字 符。 单引号(’’)和双引号( "” )本身只是一种表示方式,用来声明字符串类型,不 是字符串的一部分,因此,字符串’ hello’ 只有 h,e,l,l,o 这五 个字符。如果’本身也是字符的话,那么就可以用””括起来,比 如” I’m OK” 当中包含了一个 ’ 。如果字符串内部包含 ’ 或 者 ” ,但是又想当成普通字符串处理怎么办?这个时候就要用 转义字符( \ )来标识。\字符用于将非图形化的字符或一些特殊字符(例如,引号‘、换行\n和制表\t,或者\字符本身)进行转义。当字符串只有一个元素时,可称其为字符,如‘2’是字符,字符串是由多个字符组成的。字符串实际上就是字符的数组,每个元素都有对应的编号,称为下标,若字符串从左往右编号,则从0开始步长为1升序编号,若字符串从右往左编号,则从-1开始步长为1降序编号。下标需要与下标运算符( [ ] )一起使用。

 

#使用''或""来创建字符串,并赋值给变量。
str1 = 'I like python very much'
print(str1)
print(type(str1)) #查看str1属于哪种数据类型

#字符串索引语法:变量[下标],下标取值不能超出元素对应的最大编号,否则报错。
print(str1[0],str1[5],str1[len(str1)-1]) #len()函数用来查看对象的元素个数,str1最大下标取值为len(str1)-1.

#字符串切片语法:变量[开始下标:结束下标:步长],通过下标与步长截取一段子字符串,步长可选,默认是1.
print(str1[0:3]) #截取一段从下标0的下标2的子字符串,不包括下标为3的字符。(切片规则:选取的区间属于左闭右开型)
print(str1[2:-2]) #负数代表倒数第几个,从第三个开始到倒数第二个,不包含倒数第二个。
print(str1[2:9:2]) #从第三个开始到第九个,每隔2个元素取一个元素。

#字符串拼接:加号(+)是字符串的连接符。
str2 = ', What about you?'
print(str1+str2)

#星号(*)表示复制当前字符串。
print(str2*5) #复制当前字符串5次。

#字符转义
print('s1=','\'Hello,world\'')
print('s2=\'Hello,\\\'Adam\\\'\'')
print(r's3=\'Hello,"Bart"\'') #以r开头的字符串声明是普通字符串。规避转义符\。
print('s4=\'\'\'Hello,\nLisa!\'\'\'')

 

  字符串格式化操作

  在 Python 中,采用的格式化方式和 C 语言是一致的,用%(占位符)实现。这些占位符符为真实值预留位置,并通过参数说明真实数值应该呈现的格式。

  第二篇:python基础语法与基本数据类型

a = "I'm %s. I'm %d year old" % ('Vamei', 18) #%s为第一个格式符,表示一个字符串。%d为第二个格式符,表示一个整数。('Vamei', 99)的两个元素'Vamei'和99为替换%s和%d的真实值。
b = "I'm%+6s. I'm %d year old" % ('Vamei', 18) #%+6s表示占位6个字符,真值右对齐,不够6个字符的真值用空字符填充。
c = 'The price of apples is %.2f dollars a catty'%(2.368)
print(a)
print(b)
print(c)

  另外python还有一个更强大的字符串处理函数  str.format(),它通过{}和:来代替%。

#通过位置传值
a = "I'm {}. I'm {} year old".format('Vamei',19)
print(a)

#通过关键字传值
b = "I'm {name}. I'm {age} year old".format(age=19,name='Vamei')
print(b)

#通过下标传值
c = "I'm {1}. I'm {0} year old".format(19,'Vamei')
print(c)

#通过对象属性
class Person:
    def __init__(self,name,age):
        self.name,self.age = name,age
    def __str__(self):
        return 'This guy is {self.name},is {self.age} old'.format(self=self)
print(str(Person('Vamei',18)))

#格式限定符语法:{}中带:号,^、<、>分别是居中、左对齐、右对齐,后面带宽度,:号后面带填充的字符,只能是一个字符,不指定的话默认是用空格填充
print('{:a>8}'.format('689'))

#精度常跟类型f一起使用,b、d、o、x分别是二进制、十进制、八进制、十六进制。
print('{:.2f}'.format(321.33345))

#用,号还能用来做金额的千位分隔符。
print('{:,}'.format(1234567890))

  字符串颜色输出

  格式:\033[显示方式;前景色;背景色m

  第二篇:python基础语法与基本数据类型

#字体颜色
print("=====字体颜色======")
for i in range(31, 38):
    print("\033[%s;40mHello world!\033[0m" %i)
# 背景颜色
print("=====背景颜色======")
for i in range(41, 48):
    print("\033[47;%smHello world!\033[0m" %i)
# 显示方式
print("=====显示方式======")
for i in range(1, 9):
    print("\033[%s;31;40mHello world!\033[0m" %i)

 

  字符串和编码

  我们已经讲过了,字符串也是一种数据类型,但是,字符串比较特殊的 是还有一个编码问题。因为计算机只能处理数字,如果要处理文本,就必须先把文本转换为数 字才能处理。实际上,任何东西在计算机中表示,都需要编码。例如,视频要编码然后保存在文件中,播放的时候需要解码才能观看。

  字符编码

  由于计算机是美国人发明的,因此,最早只有 127 个字母被编码到计算 机里,也就是大小写英文字母、数字和一些符号,这个编码表被称为 ASCII 编码,如果要处理中文显然一个字节是不够的,至少需要两个字节,而且还不 能和 ASCII 编码冲突,所以,中国制定了 GB2312 编码,用来把中文编进去。但是各国有各国的标准,就会不可避免地出 现冲突,结果就是,在多语言混合的文本中,显示出来会有乱码。为了解决乱码问题,把所有语言都统一到一套编码里,于是Unicode 应运而生。Unicode 标准也在不断发展,但最常用的是用两个字节表示一个字符(如 果要用到非常偏僻的字符,就需要 4 个字节)现代操作系统和大多数 编程语言都直接支持 Unicode。现在,捋一捋 ASCII 编码和 Unicode 编码的区别:ASCII 编码是 1 个字 节,而 Unicode 编码通常是 2 个字节。新的问题又出现了:如果统一成 Unicode 编码,乱码问题从此消失了。 但是,如果你写的文本基本上全部是英文的话,用 Unicode 编码比 ASCII 编码需要多一倍的存储空间,在存储和传输上就十分不划算。所以,本着节约的精神,又出现了把 Unicode 编码转化为“可变长编码” 的 UTF-8 编码UTF-8 编码把一个 Unicode 字符根据不同的数字大小编 码成 1-6 个字节,常用的英文字母被编码成 1 个字节,汉字通常是 3 个 字节,只有很生僻的字符才会被编码成 4-6 个字节。如果你要传输的文 本包含大量英文字符,用 UTF-8 编码就能节省空间,因Unicode定义了一个“字符”和一个“数字”的对应,但是并没有规定这个“数字”在计算机中怎么保存。(就像在C中,一个整数既可以是int,也可以是short。unicode没有规定用int还是用short来表示一个“字符”,所以Unicode只是编码字符集,而UTF-8是Unicode的实现。它使用unicode定义的“字符”“数字”映射,进而规定了,如何在计算机中保存这个数字。其它的utf16等都是unicode实现。
  理论上,从一个字符到具体的编码,会经过以下几个概念。

  字符集:就算一堆抽象的字符,如所有中文。字符集的定义是抽象的,与计算机无关。
  编码字符集:是一个从整数集子集到字符集抽象元素的映射。即给抽象的字符编上数字。如gb2312中的定义的字符,每个字符都有个整数和它对应。一个整数只对应着一个字符。反过来,则不一定是。这里所说的映射关系,是数学意义上的映射关系。编码字符集也是与计算机无关的。unicode字符集也在这一层。
  字符编码方式:这个开始与计算机有关了。编码字符集的编码点在计算机里的具体表现形式。通俗的说,意思就是怎么样才能将字符所对应的整数的放进计算机内存,或文件、或网络中。于是,不同人有不同的实现方式,所谓的万码奔腾,就是指这个。gb2312,utf-8,utf-16,utf-32等都在这一层。
  字符编码方案:这个更加与计算机密切相关。具体是与操作系统密切相关。主要是解决大小字节序的问题。对于UTF-16和UTF-32
编码,Unicode都支持big-endian 和 little-endian两种编码方案。
  一般来说,我们所说的编码,都在第三层完成。具体到一个软件系统中,则很复杂。

 

  搞清楚了 ASCII、Unicode 和 UTF-8 的关系,我们就可以总结一下现在 计算机系统通用的字符编码工作方式,在计算机内存中,统一使用 Unicode 编码,当需要保存到硬盘或者需要 传输的时候,就转换为 UTF-8 编码或其他。

  用记事本编辑的时候,从文件读取的 UTF-8 字符被转换为 Unicode 字符 到内存里,编辑完成后,保存的时候再把 Unicode 转换为 UTF-8 保存到 文件:

    第二篇:python基础语法与基本数据类型

  浏览网页的时候,服务器会把动态生成的 Unicode 内容转换为 UTF-8 再 传输到浏览器:

    第二篇:python基础语法与基本数据类型

   搞清楚了令人头疼的字符编码问题后,我们再来研究 Python 的字符串。在最新的 Python 3 版本中,字符串是以 Unicode 编码的,也就是说, Python 的字符串支持多语言的字符。对于单个字符的编码,Python 提供了 ord()函数获取字符的Unicode编码chr()函数把Unicode编码转换为对应的字符

print(ord('')) #返回十进制的Unicode编码
print(chr(20013)) #传入十进制Unicode编码,返回编码对应的字符。
print(chr(0x4e2d)) #传入十六进制的Unicode编码,返回编码对应的字符。
#如果知道字符的整数编码,还可以用十六进制这么写 str
print('\u4e2d\u6587')
# 把字符串转换成Unicode编码
def str2unicode(s:str,file=None):
    '''
    string to unicode
    '''
    unicode = ''
    for i in s:
        unicode += '\\u{:0>4}'.format(str(hex(ord(i)))[2:])
    if file:
        with open(file,'w',encoding='utf-8') as f:
            f.write('[\'{}\']'.format(unicode))
            print(unicode)
        return '字符串的Unicode编码已写入文件:{}'.format(file)
    return "'{}'".format(unicode)
print(str2unicode('中文,i like you','./test.txt'))

def readUnicodeFile(file:str): ''' Read a hexadecimal Unicode encoded file :param file: file path :return: string ''' try: with open(file,'r',encoding='utf-8') as f: unicodeStr = f.read() unicodeList = eval(unicodeStr) #eval():运算字符串表达式或提取字符串所包裹的数据类型。 return unicodeList[0] except BaseException: if '\\' in file: print('找不到文件: {}'.format(file.split('\\')[-1])) else: print('找不到文件: {}'.format(file.split('/')[-1])) print(readUnicodeFile('./tes.txt'))

  由于 Python 的字符串类型是 str,在内存中以 Unicode 表示,一个字符 对应若干个字节。如果要在网络上传输,或者保存到磁盘上,就需要把 str 变为以字节为单位的 bytes。Python 对 bytes 类型的数据用带 b 前缀的单引号或双引号表示:x = b'ABC',要注意区分'ABC'和 b'ABC',前者是 str,后者虽然内容显示得和前者一 样,但 bytes 的每个字符都只占用一个字节。 以 Unicode 表示的 str 通过 encode()方法可以编码为指定的 bytes,例如:

print('Abc'.encode('utf-8')) #默认是Unicode的字符串转为utf-8.
print('中文'.encode('')) #在 bytes 中,无法显示为 ASCII 字符的字节,用\x**显示。*号是十六进制数
print('Abc'.encode('ascii'))

  反过来,如果我们从网络或磁盘上读取了字节流,那么读到的数据就是 bytes。要把 bytes 变为 str,就需要用 decode()方法:

print(b'abc'.decode('ascii'))
print(b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8'))

  len()函数计算的是 str 的字符数,如果换成 bytes,len()函数就计算字 节数。1 个中文字符经过 UTF-8 编码后通常会占用 3 个字节,而 1 个英 文字符只占用 1 个字节。

  另外,有一些文件开头写上这两行:

   第二篇:python基础语法与基本数据类型

    第一行注释是为了告诉 Linux/OS X 系统,这是一个 Python 可执行程序, Windows 系统会忽略这个注释。

    第二行注释是为了告诉 Python 解释器,按照 UTF-8 编码读取源代码, 否则,你在源代码中写的中文输出可能会有乱码。申明了 UTF-8 编码并不意味着你的.py 文件就是 UTF-8 编码的,必须并 且要确保文本编辑器正在使用 UTF-8编码。

 

  列表

  列表(list)零个或多个python对象的一个序列(有序集合),属于容器类。列表中的对象通常称为项(元素),可以是任何数据类型。列表有一个字面的表示方法,就是使用方括号( [ ] )将用逗号隔开的项括起来。和字符串一样,可以使用标准运算符对列表进行切片和连接(+),然而,返回的结果是一个新列表,而不是最初列表的一部分,最初列表未改变。和字符串不同,列表是可变的,这意味着,可以替换、插入或删除列表中所包含的项(元素),即对原列表对象的元素进行操作。列表类型包含了几个叫做修改器的方法(append、insert、pop等),它们的作用是修改一个列表的结构。

 

emptyList = [] #创建空列表
listExample = ['北京','上海',1,[2,3]]
sub_list = listExample[2] #列表索引,返回索引的元素。
sub_lists = listExample[0::2] #切片,返回新列表,并赋值给新变量。
sub_list2 = listExample[3][1] #对子对象进行索引。

#修改元素
print('listExample修改后:{}'.format(listExample))
listExample[1] = '广州'
print('listExample修改后:{}'.format(listExample))

#拼接
newList = ['a','b']
cancatList = listExample + newList
print(cancatList)

 

  元祖

  元祖是项的一个不可变的序列。元祖字面值是元素写在小括号 ” () “ 里,元素之间用逗号隔开。tuple 的元素不可改变,但是可以包含可变的对象,比如 list。元祖实际上就像列表一样,只不过它没有修改器方法。当函数返回多个值的时候,是以元组的方式返回的。函数还可以接收可变长参数,比如以 “*” 开头的参数名,会将所有的参数收集到一个元组上。

emptyTuple = ()
oneElement = (1,) #一个元素的元祖,需要在元素后面添加一个逗号
tupleExample = ('北京','上海',2,[1,3,'tuple'])
tupleExample[3][1] = 'a' #若子对象是可变类型,则可变。
print(tupleExample)

 

  集合

   集合(set)是一个无序不重复元素的序列。基本功能是进行成员关系测试和删除重复元素。可以使用大括号 {} 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 {} ,因为 {} 是用来创建一个空字典的。每个元素必须为不可变类型即(hashable类型,可作为字典的key)。

emptySet = set() #创建空集合
setElement = {'北京','上海',(3,5)}
print(setElement)

 

  字典

  字典(dictionary)是 Python 中另一个非常有用的内置数据类型,是一种映射类型。字典包含了零个或多个条目(键—值对),每个条目都将一个唯一的键和一个值相关联。键的定义必须是不可变的,即可以是数字、字符串也可以是元组,还有布尔值等。在同一个字典中,键(key) 必须是唯一的。而值的定义可以是任意数据类型。字典的字面值是将键—值条目包含到花括号(大括号)中。CPython使用伪随机探测(pseudo-random probing)的散列表(hash table)作为字典的底层数据结构。其特点是:不管字典中有多少项,in操作符花费的时间都差不多。列表是有序的对象结合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素时通过键来存取的,而不是通过偏移存取,不支持切片。列表存储空间小、查询慢。字典查询快、存储空间大,对其有 ‘空间换时间’ 的说法。

 

emptyDict = {}
dictExample = {'name':'job','age':19}

#查询
print(dictExample['name'])

#修改
dictExample['age'] = 20
print(dictExample)

#添加
dictExample['sex'] = ''
print(dictExample)

 

 

Python 数据类型转换

 

  有时候,我们需要对数据内置的内心进行转换,数据类型的转换,你只需要将数据类型作为函数名即可。以下几个内置的函数可以执行数据类型之间的转换,这些函数返回一个新的对象,表示转换的值。

 

   第二篇:python基础语法与基本数据类型

  第二篇:python基础语法与基本数据类型