Enregistrements du blog PYTHON

1. PythonUnicodeChaîne

caractère Il y a aussi un problème d'encodage avec les chaînes.

Étant donné que les ordinateurs ne peuvent traiter que des nombres, si vous souhaitez traiter du texte, vous devez d'abord convertir le texte en nombres avant traitement. Les premiers ordinateurs ont été conçus en utilisant 8 bits (bit) sous forme d'octet (octet), donc le le plus grand entier pouvant être représenté par un octet est 255 (binaire 11111111=décimal 255 ), 0 - 255 est utilisé pour représenter les lettres anglaises majuscules et minuscules, les chiffres et certains symboles. Cette table de codage est appelée ASCII . encodage, par exemple, l'encodage des lettres majuscules A est 65, et l'encodage des lettres minuscules z L'encodage de est 122.

Si vous voulez représenter le chinois, évidemment un octet ne suffit pas, il faut au moins deux octets . Et il ne peut pas entrer en conflit avec le codage ASCII, c'est pourquoi la Chine a formulé le codage GB2312 pour coder les caractères chinois.

De même, d'autres langues telles que le japonais et le coréen ont également ce problème. Afin d'unifier l'encodage de tout le texte, Unicode a vu le jour. UnicodeUnifie toutes les langues en un seul ensemble d'encodages, de sorte qu'il n'y aura plus de problèmes de code tronqué.

Unicode utilise généralement deux octets pour représenter un caractère. L'encodage anglais d'origine est passé d'un seul octet à. devient double octet, remplissez simplement l'octet de poids fort comme 0.

Parce que la naissance de Python est plus rapide que UnicodeLe standard a été publié encore plus tôt, donc le premier Python ne prend en charge que l'encodage ASCII, les chaînes ordinaires'ABC' est codé en interne en Python avec ASCII.

Python a ajouté plus tard la prise en charge de Unicode Les chaînes représentées par Unicode sont représentées par . u'...' signifie par exemple :

print u'中文'

Unicode Sauf pour Avec l'ajout de u , la chaîne n'est pas différente d'une chaîne ordinaire. Les caractères d'échappement et la représentation multiligne sont toujours valables :

<🎜. >

print u'中文\n日文\n韩文'

Lignes multiples :

u'''第一行
第二行'''

brut+Lignes multiples :

ur'''Python的Unicode字符串支持"中文",
"日文",
"韩文"等多种语言'''

Si un La chaîne chinoise rencontre UnicodeDecodeError dans l'environnement Python, c'est parce que le fichier .py est enregistré. un problème avec le format. Vous pouvez ajouter des commentaires

# -*- coding: utf-8 -*-

sur la première ligne pour indiquer à l'interpréteur Python d'utiliser <🎜 L'encodage >UTF-8 lit le code source. Utilisez ensuite Notepad++ pour enregistrer sous ... et sélectionnez le UTF-8 formater la sauvegarde.

Python Entiers moyens et nombres à virgule flottante

Python

prend en charge les opérations arithmétiques mixtes directes sur les nombres entiers et les nombres à virgule flottante. Les règles de fonctionnement sont exactement les mêmes que les quatre. règles des opérations arithmétiques en mathématiques.

Opérations de base :

1 + 2 + 3   # ==> 6
4 * 5 - 6   # ==> 14
7.5 / 8 + 2.1   # ==> 3.0375

(1 + 2) * 3    # ==> 9
(2.2 + 3.3) / (1.5 * (9 - 0.3))    # ==> 0.42145593869731807

L'utilisation de parenthèses peut augmenter la priorité, ce qui est exactement la même chose que les opérations mathématiques. Notez que seules les parenthèses peuvent être utilisées, mais les parenthèses peuvent être imbriquées sur plusieurs niveaux. : < La différence entre 🎜>

et les opérations mathématiques est que le résultat de l'opération entière de

Python est toujours un entier, et le résultat de l'opération en virgule flottante est toujours un nombre à virgule flottante :

1 + 2    # ==> 整数 3
1.0 + 2.0    # ==> 浮点

Mais le résultat de l'opération mixte d'entiers et de nombres à virgule flottante devient des nombres à virgule flottante :

为什么要区分整数运算和浮点数运算呢？这是因为整数运算的结果永远是精确的，而浮点数运算的结果不一定精确，因为计算机内存再大，也无法精确表示出无限循环小数，比如 0.1 换成二进制表示就是无限循环小数。

那整数的除法运算遇到除不尽的时候，结果难道不是浮点数吗？

11 / 4    # ==> 2

令很多初学者惊讶的是，Python的整数除法，即使除不尽，结果仍然是整数，余数直接被扔掉。不过，Python提供了一个求余的运算 % 可以计算余数：

11 % 4    # ==> 3

如果我们要计算 11 / 4 的精确结果，按照“整数和浮点数混合运算的结果是浮点数”的法则，把两个数中的一个变成浮点数再运算就没问题了：

11.0 / 4    # ==> 2.75

三、Python中布尔类型

#与运算
True and True   # ==> True
True and False   # ==> False
False and True   # ==> False
False and False   # ==> False

#或运算
True or True   # ==> True
True or False   # ==> True
False or True   # ==> True
False or False   # ==> False

#非运算
not True   # ==> False
not False   # ==> True

a = True
print a and 'a=T' or 'a=F'
#计算结果不是布尔类型，而是字符串 'a=T'，这是为什么呢？

#因为Python把0、空字符串''和None看成 False，其他数值和非空字符串都看成 True，所以：

True and 'a=T' #计算结果是 'a=T'
#继续计算 'a=T' or 'a=F' 计算结果还是 'a=T'

要解释上述结果，又涉及到 and 和 or 运算的一条重要法则：短路计算。

1. 在计算 a and b 时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。

2. 在计算 a or b 时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。

所以Python解释器在做布尔运算时，只要能提前确定计算结果，它就不会往后算了，直接返回结果。

四、Python创建list

Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。

比如，列出班里所有同学的名字，就可以用一个list表示：

>>> ['Michael', 'Bob', 'Tracy']
['Michael', 'Bob', 'Tracy']

list是数学意义上的有序集合，也就是说，list中的元素是按照顺序排列的。

构造list非常简单，按照上面的代码，直接用 [ ] 把list的所有元素都括起来，就是一个list对象。通常，我们会把list赋值给一个变量，这样，就可以通过变量来引用list：

classmates = ['Michael', 'Bob', 'Tracy']
classmates # 打印classmates变量的内容
>>>['Michael', 'Bob', 'Tracy']

由于Python是动态语言，所以list中包含的元素并不要求都必须是同一种数据类型，我们完全可以在list中包含各种数据：

L = ['Michael', 100, True]

一个元素也没有的list，就是空list：

empty_list = []

#打印成绩表
L = ['adam', 95.5,'lisa', 85,'bart', 59]
print L

五、Python按照索引访问list

由于list是一个有序集合，所以，我们可以用一个list按分数从高到低表示出班里的3个同学：

L = ['Adam', 'Lisa', 'Bart']

那我们如何从list中获取指定第 N 名的同学呢？方法是通过索引来获取list中的指定元素。

需要特别注意的是，索引从 0 开始，也就是说，第一个元素的索引是0，第二个元素的索引是1，以此类推。

因此，要打印第一名同学的名字，用 L[0]:

但使用索引时，千万注意不要越界，所以没有L[3]。

六、Python之倒序访问list

L = ['Adam', 'Lisa', 'Bart']
print L[-1]
>>>Bart

七、Python之list添加新元素

L = ['Adam', 'Lisa', 'Bart']

把新同学Paul添加到现有的 list 中

7.1append()

第一个办法是用 list 的 append() 方法，把新同学追加到 list 的末尾：

L = ['Adam', 'Lisa', 'Bart']
L.append('Paul')
print L
>>> ['Adam', 'Lisa', 'Bart', 'Paul']

append()总是把新的元素添加到 list 的尾部。

7.2insert()

用list的 insert()方法，它接受两个参数，第一个参数是索引号，第二个参数是待添加的新元素：

L = ['Adam', 'Lisa', 'Bart']
L.insert(0, 'Paul')
print L
>>>['Paul', 'Adam', 'Lisa', 'Bart']

L.insert(0, 'Paul') 的意思是，'Paul'将被添加到索引为 0 的位置上（也就是第一个），而原来索引为 0 的Adam同学，以及后面的所有同学，都自动向后移动一位。

八、Python从list删除元素

 L = ['Adam', 'Lisa', 'Bart', 'Paul']
L.pop()
>>>'Paul'
 print L
>>>['Adam', 'Lisa', 'Bart']

pop()默认删除最后一个，当让也可以指定

L = ['Adam', 'Lisa', 'Paul', 'Bart']
L.pop(2)
>>>'Paul'
print L
>>> ['Adam', 'Lisa', 'Bart']

九、Python之List中替换元素

L = ['Adam', 'Lisa', 'Paul', 'Bart']
L[2] = 'Paul' #或者 L[-1] = 'Paul'
print L
>>> L = ['Adam', 'Lisa', 'Paul']

十、Python之创建tuple

tuple是另一种有序的列表，中文翻译为“ 元组 ”。tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修改了。

同样是表示班里同学的名称，用tuple表示如下：

t = ('Adam', 'Lisa', 'Bart')

　　

创建tuple和创建list唯一不同之处是用( )替代了[ ]。

现在，这个 t 就不能改变了，tuple没有 append()方法，也没有insert()和pop()方法。所以，新同学没法直接往 tuple 中添加，老同学想退出 tuple 也不行。

获取 tuple 元素的方式和 list 是一模一样的，我们可以正常使用 t[0]，t[-1]等索引方式访问元素，但是不能赋值成别的元素

十一、Python之创建单元素tuple

tuple和list一样，可以包含 0 个、1个和任意多个元素。

包含多个元素的 tuple，前面我们已经创建过了。

包含 0 个元素的 tuple，也就是空tuple，直接用 ()表示：

t = ()
print t
>>>()

　　

 t = (1)
print t
>>> 1
#？？？这是为什么，因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果 (1) 被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1。

　　

正是因为用()定义单元素的tuple有歧义，所以 Python 规定，单元素 tuple 要多加一个逗号“,”，这样就避免了歧义：

t = (1,)
print t
>>>(1,)

Python在打印单元素tuple时，也自动添加了一个“,”，为了更明确地告诉你这是一个tuple。

多元素 tuple 加不加这个额外的“,”效果是一样的。

十二、Python之“可变”的tuple

t = ('a', 'b', ['A', 'B'])
#t = ('a', 'b', ('A', 'B'))的话就是不可变的

注意到 t 有 3 个元素：'a'，'b'和一个list：['A', 'B']。list作为一个整体是tuple的第3个元素。list对象可以通过 t[2] 拿到：

 L = t[2]
L[0] = 'X'
L[1] = 'Y'
print t
>>>('a', 'b', ['X', 'Y'])

　

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!