betway必威-betway必威官方网站
做最好的网站

Python字符编码,数据类型

  1. 数据结构回顾

一.字符编码

字符串也是一种数据类型,但是,字符串比较特殊的是还有一个编码问题。

因为计算机只能处理数字,如果要处理文本,就必须先把文本转换为数字才能处理。最早的计算机在设计时采用8个比特(bit)作为一个字节(byte),所以,一个字节能表示的最大的整数就是255(二进制11111111=十进制255),如果要表示更大的整数,就必须用更多的字节。比如两个字节可以表示的最大整数是65535,4个字节可以表示的最大整数是4294967295

由于计算机是美国人发明的,因此,最早只有127个字符被编码到计算机里,也就是大小写英文字母、数字和一些符号,这个编码表被称为ASCII编码,比如大写字母A的编码是65,小写字母z的编码是122。

但是要处理中文显然一个字节是不够的,至少需要两个字节,而且还不能和ASCII编码冲突,所以,中国制定了GB2312编码,用来把中文编进去。

你可以想得到的是,全世界有上百种语言,日本把日文编到Shift_JIS里,韩国把韩文编到Euc-kr里,各国有各国的标准,就会不可避免地出现冲突,结果就是,在多语言混合的文本中,显示出来会有乱码。

因此,Unicode应运而生。Unicode把所有语言都统一到一套编码里,这样就不会再有乱码问题了。

Unicode标准也在不断发展,但最常用的是用两个字节表示一个字符(如果要用到非常偏僻的字符,就需要4个字节)。现代操作系统和大多数编程语言都直接支持Unicode。

现在,捋一捋ASCII编码和Unicode编码的区别:ASCII编码是1个字节,而Unicode编码通常是2个字节。

字母A用ASCII编码是十进制的65,二进制的01000001;

字符0用ASCII编码是十进制的48,二进制的00110000,注意字符'0'和整数0是不同的;

汉字中已经超出了ASCII编码的范围,用Unicode编码是十进制的20013,二进制的01001110 00101101。

你可以猜测,如果把ASCII编码的A用Unicode编码,只需要在前面补0就可以,因此,A的Unicode编码是00000000 01000001。

新的问题又出现了:如果统一成Unicode编码,乱码问题从此消失了。但是,如果你写的文本基本上全部是英文的话,用Unicode编码比ASCII编码需要多一倍的存储空间,在存储和传输上就十分不划算。

所以,本着节约的精神,又出现了把Unicode编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节,常用的英文字母被编码成1个字节,汉字通常是3个字节,只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符,用UTF-8编码就能节省空间:

图片 1

从上面的表格还可以发现,UTF-8编码有一个额外的好处,就是ASCII编码实际上可以被看成是UTF-8编码的一部分,所以,大量只支持ASCII编码的历史遗留软件可以在UTF-8编码下继续工作。

搞清楚了ASCII、Unicode和UTF-8的关系,我们就可以总结一下现在计算机系统通用的字符编码工作方式:

在计算机内存中,统一使用Unicode编码,当需要保存到硬盘或者需要传输的时候,就转换为UTF-8编码。

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

Python基础系列----语法、数据类型、变量、编码,python----

基本语法

  Python的语法比较简单,采用缩进的方式。

图片 2# print absolute value of an integer: a = 100 if a >= 0: print(a) else: print(-a) View Code

  在上面代码中,以‘# ’是注释的标识符,可以记录当前代码所代表的意义,解释器会自动忽略这部分内容。

  当语句以‘:’结尾时,缩进语句视为代码块。

  在Python中,通常我们以4个空格的缩进来进行区分。由于个人习惯原因,可以在每句结束之后加一个‘;’号。通常在Python中,默认以换行为新的一行,若想在一行输入多句语句,一定要加‘;’,否则报错。由于Python采用缩进的语法,在你复制,粘贴语句时,一定要注意,重新检查当前代码的缩进格式。IDE很难格式化代码。

  注意:在Python中,对大小写十分敏感,如果大小写错误,会报错。

数据类型

  数据类型:一个值的集合以及定义在这个值集上的一组操作

  Python提供的基本数据类型主要有:布尔类型、整型、浮点型、字符串、空值、列表、元组、集合、字典等等。在这里主要介绍布尔类型、整型、浮点型、字符串、空值,其他的后续介绍。

 

  布尔类型

    在Python中,None、任何数值中的0、空字符串、空元组、空列表、空字典都被当做false,还要自定义的 方法返回0或者false,则其实例当做False,其他对象均为Ture。

 

图片 3>>>True True >>>False False >>>1>0 True >>>1>2 False View Code

 

 

     布尔类型只有两个值,不是true,就是false。布尔值可以进行运算,主要包括and,or,not

      a.and  与运算,只有所有都为true,返回结果为true

      b.or    或运算,只要其中有一个为true,返回结果为true

      c.not  是非运算,它是一个但亩运算符,把true变为false,false变为true

图片 4>>>True and True True >>>True and False False >>>False and False False >>>True or False or True True >>>not True False >>>not False True View Code

  整形

    在Python内部对整数的处理分为普通整数和长整数,普通整数长度为机器位长,通常都是32位,超过这个范围的整数就自动当长整数处理,而长整数的范围几乎完全没限制。例如:1,2,-1,1000000

  浮点型

    Python的浮点数就是数学中的小数,类似C#语言中的double。在运算中,整数与浮点数运算的结果是浮点数,浮点数也就是小数,之所以称为浮点数,是因为按照科学记数法表示时,一个浮点数的小数点位置是可变的,比如,1.23x109和12.3x108是相等的。整数和浮点数在计算机内部存储的方式是不同的,整数运算永远是精确的,而浮点数运算则可能会有四舍五入的误差。

  字符串

   Python字符串即可以用单引号也可以用双引号括起来,甚至还可以用三引号括起来。例如:‘abc’,"abc",'''I'm OK'''等。''或""本身只是一种表示方式,不是字符串的一部分。

    如果字符串内部既包含'又包含",可以使用转义符来标识。转义字符可以转义很多字符,比如n表示换行,t表示制表符,字符本身也要转义,所以\表示的字符就是。

    如果字符串里面有很多字符都需要转义,就需要加很多,为了简化,Python还允许用r''表示''内部的字符串默认不转义.如果字符串内部有很多换行,用n写在一行里不好阅读,为了简化,Python允许用'''...'''的格式表示多行内容

  空值**

  空值是Python里一个特殊的值,用None表示。None不能理解为0,因为0是有意义的,而None是一个特殊的空值。

变量  

 

变量名必须是大小写英文、数字和_的组合,且不能用数字开头.变量本身类型不固定的语言称之为动态语言,与之对应的是静态语言。静态语言在定义变量时必须指定变量类型,如果赋值的时候类型不匹配,就会报错

a = 'ABC' 
b = a 
a = 'XYZ'
print(b)

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

图片 5

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

图片 6

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

 图片 7

  最后打印变量b,输出值为‘ABC’。

编码

  在创建Python文件时,有些IDE会在文件最上方有这样一段代码  

#-*- coding: UTF-8 -*-

  这段代码表示,当前文件以utf-8的格式编码。有时,在浏览网页,或者打开文件时,发现全部是一堆看不懂的字符串,这就是乱码,也是由文件编码导致的。由于每个国家的语言不同,各国有各国的标准,如果多种语言的文本混合其中,这时就会导致乱码。因此为了将所有语言统一到一套编码规范中,产生了Unicode,这样就不会再存在乱码的情况了。 Unicode标准也在不断发展,但最常用的是用两个字节表示一个字符(如果要用到非常偏僻的字符,就需要4个字节)。现代操作系统和大多数编程语言都直接支持Unicode。在Python中,我们通常都需要指定当前文件具体的一种编码格式,避免后期产品乱码的情况。

  ASCII编码和Unicode编码的区别:  

    ASCII编码是1个字节,而Unicode编码通常是2个字节。
    字母A用ASCII编码是十进制的65,二进制的01000001;

    字符0用ASCII编码是十进制的48,二进制的00110000,注意字符'0'和整数0是不同的;

    汉字中已经超出了ASCII编码的范围,用Unicode编码是十进制的20013,二进制的01001110 00101101。

  如果统一成Unicode编码,乱码问题从此消失了。但是,如果你写的文本基本上全部是英文的话,用Unicode编码比ASCII编码需要多一倍的存储空间,在存储和传输上就十分不划算。 所以,本着节约的精神,又出现了把Unicode编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节,常用的英文字母被编码成1个字节,汉字通常是3个字节,只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符,用UTF-8编码就能节省空间

    

字符 ASCII Unicode UTF-8
A 01000001 00000000 01000001 01000001
x 01001110 00101101 11100100 10111000 10101101

  计算机系统通用的字符编码工作方式: 在计算机内存中,统一使用Unicode编码,当需要保存到硬盘或者需要传输的时候,就转换为UTF-8编码。

 

  在Python中, ord()函数获取字符的整数表示; chr()函数把编码转换为对应的字符。

>>> ord('A')
65
>>> ord('中')
20013
>>> chr(66)
'B'
>>> chr(25991)
'文'

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

  以Unicode表示的str通过encode()方法可以编码为指定的bytes。要把bytes变为str,就需要用decode()方法

图片 8>>> 'ABC'.encode('ascii') b'ABC' >>> '中文'.encode('utf-8') b'xe4xb8xadxe6x96x87' View Code

  Python源代码也是一个文本文件,所以,当你的源代码中包含中文的时候,在保存源代码时,就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时,为了让它按UTF-8编码读取,我们通常在文件开头写上这两行。#!/usr/bin/env python3# -*- coding: utf-8 -*-。第一行注释是为了告诉Linux/OS X系统,这是一个Python可执行程序,Windows系统会忽略这个注释;第二行注释是为了告诉Python解释器,按照UTF-8编码读取源代码,否则,你在源代码中写的中文输出可能会有乱码。

 

  格式化

    采用的格式化方式和C语言是一致的,用%实现。

>>> 'Hello, %s' % 'world''Hello, world'>>> 'Hi, %s, you have $%d.' % ('Michael', 1000000)
'Hi, Michael, you have $1000000.'

    %运算符就是用来格式化字符串的。在字符串内部,%s表示用字符串替换,%d表示用整数替换,有几个%?占位符,后面就跟几个变量或者值,顺序要对应好。如果只有一个%?,括号可以省略

     常见占位符:%d(整数),%f(浮点数),%s(字符串),%x(十六进制整数)

     格式化整数和浮点数还可以指定是否补0和整数与小数的位数

>>> '--d' % (3, 1)
' 3-01'>>> '%.2f' % 3.1415926'3.14'

      有些时候,字符串里面的%是一个普通字符,这个时候就需要转义,用%%来表示一个%

>>> 'growth rate: %d %%' % 7'growth rate: 7 %'

写在最后

  以上就是Python的一些基本语法、数据类型、编码知识,有存在错误或不足的地方,及时沟通改正。下篇的时间可能要稍微朝后推迟了,周末需要去做个身体检查,也希望大家的身体棒棒的! 

 

基本语法 Python的语法比较简单,采用缩进的方式。 # print absolute value of an integer:...

  图片 9

1.1 Python的字符串

在最新的Python 3版本中,字符串是以Unicode编码的,默认存储以UTF-8,但是Python 2默认存储以Unicode编码。

所有标准序列操作(索引、切片、乘法、成员资格检查、长度、最小值和最大值)都适用于字符串,但是字符串是不可变序列,因此所有的元素赋值和切片赋值都是非法的

1.1.1 对于单个字符的编码,Python提供了ord()函数获取字符的整数表示,chr()函数把编码转换为对应的字符:
>>> ord('A')
65
>>> ord('中')
20013
>>> chr(66)
'B'
>>> chr(25991)
'文'

图片 10图片 11

1.1.2 Python的字符串类型是str,在内存中以Unicode表示,一个字符对应若干个字节。如果要在网络上传输,或者保存到磁盘上,就需要把str变为以字节为单位的bytes。Python对bytes类型的数据用带b前缀的单引号或双引号表示
x = b'ABC'
>>> website = 'http://www.python.org'
>>> website[-3:] = 'com'
Traceback (most recent call last):
File "<pyshell#19>", line 1, in ?
website[-3:] = 'com'
TypeError: object doesn't support slice assignment
1.1.3 由于Python源代码也是一个文本文件,所以,当你的源代码中包含中文的时候,在保存源代码时,就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时,为了让它按UTF-8编码读取,我们通常在文件开头写上这两行:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
第一行注释是为了告诉Linux/OS X系统,这是一个Python可执行程序,Windows系统会忽略这个注释;
第二行注释是为了告诉Python解释器,按照UTF-8编码读取源代码,否则,你在源代码中写的中文输出可能会
有乱码(python3默认支持UTF-8,在Python3不用写)。
"""

View Code

二.输出格式化

Python两种输出值的方式: 表达式语句和 print() 函数。
第三种方式是使用文件对象的 write() 方法,标准输出文件可以用 sys.stdout 引用。
如果你希望输出的形式更加多样,可以使用 str.format() 函数来格式化输出值。
如果你希望将输出的值转成字符串,可以使用 repr()str() 函数来实现。

  • str(): 函数返回一个用户易读的表达形式。
  • repr(): 产生一个解释器易读的表达形式。
>>> str(1/7)
'0.14285714285714285'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'x 的值为: '   repr(x)   ',  y 的值为:'   repr(y)   '...'
>>> print(s)
x 的值为: 32.5,  y 的值为:40000...
>>> #  repr() 函数可以转义字符串中的特殊字符
... hello = 'hello, runoobn'
>>> hellos = repr(hello)
>>> print(hellos)
'hello, runoobn'
>>> # repr() 的参数可以是 Python 的任何对象
... repr((x, y, ('Google', 'Runoob')))
"(32.5, 40000, ('Google', 'Runoob'))"
  • 字符串对象的rjust()方法, 它可以将字符串靠右, 并在左边填充空格。还有类似的方法, 如 ljust()center()。 这些方法并不会写任何东西, 它们仅仅返回新的字符串。
    另一个方法 zfill(), 它会在数字的左边填充 0。
>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'
  • str.format() 的基本使用如下:
>>> print('{}网址: "{}!"'.format('菜鸟教程', 'www.runoob.com'))
菜鸟教程网址: "www.runoob.com!"

"""
括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换。
在括号中的数字用于指向传入对象在 format() 中的位置
"""
>>> print('{0} 和 {1}'.format('Google', 'Runoob'))
Google 和 Runoob
>>> print('{1} 和 {0}'.format('Google', 'Runoob'))
Runoob 和 Google
>>> print('{name}网址: {site}'.format(name='菜鸟教程', site='www.runoob.com'))
菜鸟教程网址: www.runoob.com
  • !a (使用 ascii()), !s (使用 str()) 和'!r'(使用 repr()) 可以用于在格式化某个值之前对其进行转化
>>> import math
>>> print('常量 PI 的值近似为: {}。'.format(math.pi))
常量 PI 的值近似为: 3.141592653589793。
>>> print('常量 PI 的值近似为: {!r}。'.format(math.pi))
常量 PI 的值近似为: 3.141592653589793。
  • 可选项 ':' 和格式标识符可以跟着字段名。 这就允许对值进行更好的格式化。
>>> import math
>>> print('常量 PI 的值近似为 {0:.3f}。'.format(math.pi))  #  将 Pi 保留到小数点后三位
常量 PI 的值近似为 3.142。

>>> table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
>>> for name, number in table.items():
...     print('{0:10} ==> {1:10d}'.format(name, number))  #  在 ':' 后传入一个整数, 可以保
# 证该域至少有这么多的宽度。 用于美化表格时很有用
...
Runoob     ==>          2
Taobao     ==>          3
Google     ==>          1
  • 如果你有一个很长的格式化字符串, 而你不想将它们分开, 那么在格式化时通过变量名而非位置会是很好的事情。
    最简单的就是传入一个字典, 然后使用方括号 []来访问键值 :
>>> table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
>>> print('Runoob: {0[Runoob]:d}; Google: {0[Google]:d}; Taobao: {0[Taobao]:d}'.format(t
able))
Runoob: 2; Google: 1; Taobao: 3
"""
也可以通过在 table 变量前使用 '**' 来实现相同的功能
"""
>>> print('Runoob: {Runoob:d}; Google: {Google:d}; Taobao: {Taobao:d}'.format(**table))
Runoob: 2; Google: 1; Taobao: 3
  • 旧式字符串格式化
"""
% 操作符也可以实现字符串格式化。 它将左边的参数作为类似 sprintf() 式的格式化字符串, 而将右边的
代入, 然后返回格式化后的字符串.因为str.format() 比较新的函数, 大多数的 Python 代码仍然使用 % 
操作符。但是因为这种旧式的格式化最终会从该语言中移除, 应该更多的使用 str.format().
"""
>>> import math
>>> print('常量 PI 的值近似为:%5.3f。' % math.pi)
常量 PI 的值近似为:3.142。
  • 读取键盘输入
"""
Python提供了 input() 置函数从标准输入读入一行文本,默认的标准输入是键盘。
input 可以接收一个Python表达式作为输入,并将运算结果返回
"""
#!/usr/bin/python3

str = input("请输入:");
print ("你输入的内容是: ", str)
  • 数字格式化
    ^, <,> 分别是居中、左对齐、右对齐,后面带宽度, : 号后面带填充的字符,只能是一个字符,不指定则默认是用空格填充。 表示在正数前显示 ,负数前显示-; (空格)表示在正数前加空格。b、d、o、x 分别是二进制、十进制、八进制、十六进制。
    eg: print("{:.2f}".format(3.1415926)) 结果:3.14
数字 格式 输出 描述
3.1415926 {:.2f} 3.14 保留小数点后两位
3.1415926 {: .2f} 3.14 带符号保留小数点后两位
-1 {: .2f} -1.00 带符号保留小数点后两位
2.71828 {:.0f} 3 不带小数
5 {:0>2d} 05 数字补零 (填充左边, 宽度为2)
5 {:x<4d} 5xxx 数字补x (填充右边, 宽度为4)
10 {:x<4d} 10xx 数字补x (填充右边, 宽度为4)
1000000 {:,} 1,000,000 以逗号分隔的数字格式
0.25 {:.2%} 25.00% 百分比格式
1000000000 {:.2e} 1.00e 09 指数记法
13 {:10d} 13 右对齐 (默认, 宽度为10)
13 {:<10d} 13 左对齐 (宽度为10)
13 {:^10d} 13 中间对齐 (宽度为10)
11 '{:b}'.format(11) 1011 进制
11 '{:d}'.format(11) 11 进制
11 '{:o}'.format(11) 13 进制
11 '{:x}'.format(11) b 进制
11 '{:#x}'.format(11) 0xb 进制
11 '{:#X}'.format(11) 0XB 进制

通过名称来访问其各个值的数据结构。这种数据结构称为映射(mapping) 。字典是Python中唯一的内置映射类型,其中的值不按顺序排列,而是(值)存储在键下。键可能是数、字符串或元组。

三.数据运算符

  • 算术运算符
  • 比较(关系)运算符
  • 赋值运算符
  • 逻辑运算符
  • 位运算符
  • 成员运算符
  • 身份运算符
  • 运算符优先级
  1. 字符串
3.1 算术运算符
运算符 描述 实例
加 - 两个对象相加 a b 输出结果 31
- 减 - 得到负数或是一个数减去另一个数 a - b 输出结果 -11
* 乘 - 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 210
/ 除 - x 除以 y b / a 输出结果 2.1
% 取模 - 返回除法的余数 b % a 输出结果 1
** 幂 - 返回x的y次幂 a**b 为10的21次方
// 取整除 - 返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0

print ( "hello,world!")    "hello,world!" 是字符串,字符串在几乎所有真实可用的Python程序中都会存在,并且有多种用法,其中最主要的用法就是表示一些文本。字符串是值,就像数字一样。str,repr和反引号是将Python值转换成 字符串的3种方法。

3.2 比较运算符

以下假设变量a为10,变量b为20:

运算符 描述 实例
== 等于 - 比较对象是否相等 (a == b) 返回 False
!= 不等于 - 比较两个对象是否不相等 (a != b) 返回 True
> 大于 - 返回x是否大于y (a > b) 返回 False
< 小于 - 返回x是否小于y。所有比较运算符返回1表示真,返回0表示假。这分别与特殊的变量True和False等价。注意,这些变量名的大写 (a < b) 返回 True
>= 大于等于 - 返回x是否大于等于y。 (a >= b) 返回 False
<= 小于等于 - 返回x是否小于等于y。 (a <= b) 返回 True

2.1 字符串基础

3.3 赋值运算符
运算符 描述 实例
= 简单的赋值运算符 c = a b 将 a b 的运算结果赋值为 c
= 加法赋值运算符 c = a 等效于 c = c a
-= 减法赋值运算符 c -= a 等效于 c = c - a
*= 乘法赋值运算符 c *= a 等效于 c = c * a
/= 除法赋值运算符 c /= a 等效于 c = c / a
//= 取整除赋值运算符 c //= a 等效于 c = c // a
%= 取模赋值运算符 c %= a 等效于 c = c % a
**= 幂赋值运算符 c **= a 等效于 c = c ** a

a. 单引号字符串和转义引号

3.4 位运算符

按位运算符是把数字看作二进制来进行计算的。下表中变量 a 为 60,b 为 13,二进制 a = 0011 1100, b = 0000 1101

运算符 描述 实例
& 按位与运算符:参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 (a & b) 输出结果 12 ,二进制解释: 0000 1100
| 按位或运算符:只要对应的二个二进位有一个为1时,结果位就为1。 (a | b) 输出结果 61 ,二进制解释: 0011 1101
^ 按位异或运算符:当两对应的二进位相异时,结果为1 (a ^ b) 输出结果 49 ,二进制解释: 0011 0001
~ 按位取反运算符:对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1 (~a ) 输出结果 -61 ,二进制解释: 1100 0011, 在一个有符号二进制数的补码形式。
<< 左移动运算符:运算数的各二进位全部左移若干位,由"<<"右边的数指定移动的位数,高位丢弃,低位补0。 a << 2 输出结果 240 ,二进制解释: 1111 0000
>> 右移动运算符:把">>"左边的运算数的各二进位全部右移若干位,">>"右边的数指定移动的位数 a >> 2 输出结果 15 ,二进制解释: 0000 1111

>>> 'let's go'          # 后面的黑色字体部分Python无法识别
SyntaxError: invalid syntax
>>> 'let's go'          # 在常规字符串中,反斜杠扮演着特殊角色:它对字符进行转义,让你能够在字符串中包含原本无法包含的字符。   反斜线(),可以换行。
"let's go"
>>> "let's go!"         # 用""对'加以区分
"let's go!"

3.5 逻辑运算符

Python语言支持逻辑运算符,以下假设变量 a 为 10, b为 20:

运算符 逻辑表达式 描述 实例
and x and y 布尔"与" - 如果 x 为 False,x and y 返回 False,否则它返回 y 的计算值。 (a and b) 返回 20
or x or y 布尔"或" - 如果 x 是 True,它返回 x 的值,否则它返回 y 的计算值。 (a or b) 返回 10
not not x 布尔"非" - 如果 x 为 True,返回 False 。如果 x 为 False,它返回 True。 not(a and b) 返回 False

b. 拼接字符串

3.6 成员运算符

除了以上的一些运算符之外,Python还支持成员运算符,测试实例中包含了一系列的成员,包括字符串,列表或元组。

运算符 描述 实例
in 如果在指定的序列中找到值返回 True,否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True
not in 如果在指定的序列中没有找到值返回 True,否则返回 False x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True

>>> "let's say:" '"hello,world!"'
'let's say:"hello,world!"'
>>> 'hello,' 'world!'        
'hello,world!'

3.7 身份运算符

身份运算符用于比较两个对象的存储单元

运算符 描述 实例
is is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True,否则返回 False
is not is not 是判断两个标识符是不是引用自不同对象 x is not y , 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True,否则返回 False

is和==的区别:
is 用于判断两个变量引用对象是否为同一个, == 用于判断引用变量的值是否相等。

  可以使用 操作符来连接 (粘在一起); 使用 * 操作符重复

3.8 运算符优先级

以下表格列出了从最高到最低优先级的所有运算符:

运算符 描述
** 指数 (最高优先级)
~ - 按位翻转, 一元加号和减号 (最后两个的方法名为 @ 和 -@)
* / % // 乘,除,取模和取整除
- 加法减法
>> << 右移,左移运算符
& 位 'AND'
^ | 位运算符
<= < > >= 比较运算符
<> == != 等于运算符
= %= /= //= -= = *= **= 赋值运算符
is is not 身份运算符
in not in 成员运算符
not or and 逻辑运算符

>>> word = 'help ' 'me! '
>>> word
'help me! '
>>> '<' word * 4 '>'
'<help me! help me! help me! help me! >'
>>>

注意:

两个靠着一起的字符串会自动的连接; 上面例子的第一行也可以写成 word = 'Help' 'A'; 这只能用于两个字符串常量, 而不能用于任意字符串表达式。

c. 字符串表示,str和repr

Python打印值的时候会保持值在代码中的状态,而不是你希望用户看到的状态,通过使用print,结果将不同。

>>> "Hello, world!"
'Hello, world!'
>>> print("Hello, world!")
Hello, world!

如果再加上表示换行符的编码n,差别将更明显。

>>> 'hello,nworld!'
'hello,nworld!'
>>> print('hello,nworld!')
hello,
world!
>>>

   str,repr和反引号是将Python值转换成 字符串的3种方法。

repr() 函数,

通常会获得值的合法Python表达式表示。则意味着产生一个解释器易读的表达形式 (或者如果没有这样的语法会给出 SyntaxError ).

str() 函数 ,(实际是类,工厂函数;str和int、long一样,是一种类型。repr仅仅是函数)

使用str能以合理的方式将值转换为用户能够看懂的字符串。例如,尽可能将特殊字符编码转换为相应的字符。

 对于那些没有特殊表达的对象, str() 将会与 repr() 返回相同的值. 很多的值, 如数字或一些如列表和字典那样的结构, 使用这两个函数的结果完全一致. 字符串与浮点型则有两种不同的表达。

  repr和反引号则把结果字符串转换为合法的Python表达式。

  d. 长字符串,原始字符串和Unicode

有一些独特而有用的字符串表示方式。例如,有一种独特的语法可用于表示包含换行符或反斜杠的字符串(长字符串和原始字符串)。对于包含特殊符号的字符串,

 Python 2还提供了一种专用的表示语法,结果为Unicode字符串。这种语法现在依然管用,但是多余,因为在Python 3中,所有的字符串都是Unicode字符串。 Python 3还引入了一种新语法,用于表示大致相当于老式字符串的字节对象。在处理Unicode编码方面,这种对象依然扮演着重要的角色。

请注意,指定原始字符串时,可使用单引号或双引号将其括起,还可使用三引号将其括起。

             i. 长字符串

字符串可以使用一对匹配的三引号对包围: """ 或 '''。当使用三引号时, 回车不需要被舍弃, 他们会包含在字符串里。

>>> print('''This is a very long string. It continues here.
And it's not over yet. "Hello, world!"
Still here.''')
This is a very long string. It continues here.
And it's not over yet. "Hello, world!"
Still here.
>>>

             ii. 原始字符串

原始字符串不以特殊方式处理反斜线。  

>>> path = 'C:nowhere'
>>> path
'C:nowhere'
>>> print(path)                     # 打印出问题
C:
owhere
>>> print('C:\nowhere')       #对反斜杠本身进行转义。
C:nowhere
>>>

  对于很长的路径,将需要使用大量的反斜杠。

在这样的情况下,原始字符串可派上用场,因为它们根本不会对反斜杠做特殊处理,而是让字符串包含的每个字符都保持原样。

>>> print(r'C:nowhere')
C:nowhere
>>> print(r'C:Program Filesfnordfoobarbazfrozzbozz')
C:Program Filesfnordfoobarbazfrozzbozz
>>>

       iii.  Unicode、 bytes和bytearray

Python字符串与二进制的关系

python 3中最重要的新特性可能就是将文本(text)和二进制数据做了更清晰的区分。文本总是用unicode进行编码,以str类型表示;而二进制数据以bytes类型表示。

在python3中,不能以任何隐式方式将str和bytes类型二者混合使用。不可以将str和bytes类型进行拼接,不能在str中搜索bytes数据(反之亦然),也不能将str作为参数传入需要bytes类型参数的函数(反之亦然)。

Unicode

大致而言,每个Unicode字符都用一个码点(code point)表示,而码点是Unicode标准给每个字符指定的数字。这让你能够以任何现代软件都能识别的方式表示129个文字系统中的12万个以上的字符。当然,鉴于计算机键盘不可能包含几十万个键,因此有一种指定Unicode字符的通用机制:使用16或32位的十六进制字面量(分别加上前缀u或U)或者使用字符的Unicode名称(N{name})。

>>> "u00C6"
'Æ'

要获悉字符的Unicode码点和名称,可在网上使用有关该字符的描述进行搜索,也可参阅特定的网站,如

Bytes

Unicode的理念很简单,却带来了一些挑战,其中之一是编码问题。在内存和磁盘中,所有对象都是以二进制数字(0和1)表示的(这些数字每8个为一组,即1字节),字符串也不例外。在诸如C等编程语言中,这些字节完全暴露,而字符串不过是字节序列而已。为与C语言互操作以及将文本写入文件或通过网络套接字发送出去,Python提供了两种类似的bytes类型:不可变的bytes和可变的bytearray。如果需要,可直接创建bytes对象(而不是字符串),方法是使用前缀b:

>>> b'Hello, world!'
b'Hello, world!

然而, 1字节只能表示256个不同的值,离Unicode标准的要求差很远。 Python bytes字面量只支持ASCII标准中的128个字符,而余下的128个值必须用转义序列表示,如xf0表示十六进制值0xf0(即240)。   8位一个字节,一位是一个bite,8位最多表示255个符号。

唯一的差别好像在于可用的字母表规模,但实际上并非完全如此。乍一看,好像ASCII和Unicode定义的都是非负整数和字符之间的映射,但存在细微的差别: Unicode码点是使用整数定义的,而ASCII字符是使用对应的数及其二进制编码定义的。

本文由betway必威发布于编程开发,转载请注明出处:Python字符编码,数据类型

TAG标签: betway必威
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。