Exemple d'analyse de code d'introduction au type de données Python

Variables

Les variables stockent les valeurs. En python, ce sont les conventions de dénomination des variables :

• Les variables doivent commencer par une lettre (de préférence minuscule) ou un trait de soulignement, et peuvent être suivies par un chiffre ou un trait de soulignement

• La casse serpent est la manière normale d'écrire un variable comme user_name , les mots sont séparés par des traits de soulignement (Javascript recommande la dénomination en casse chameau, telle que : userName)user_name，单词间用下划线隔开（Javascript推荐驼峰命名，比如：userName）

• 它们区分大小写

• 不能直接命名关键词变量（查看官方文档《Python 关键字》）

那么如果，真的犯了这个错，会怎么样呢？举个例子：

>>> if = 1
SyntaxError: invalid syntax
>>> print(and)
SyntaxError: invalid syntax
>>> def = "hi"
SyntaxError: invalid syntax

看到没有？直接提示语法错误。

除了不能使用关键字作为标识符，前面我们也强调过了，也不能使用内置函数同名的标识符。Python有很多内置函数，以sum为例，这是一个求和的函数，我们看一下错误的命名导致的后果：

>>> sum([1,2,3,4])
10
>>> sum = "错误标识符名"
>>> sum([1,2,3,4])
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
    sum([1,2,3,4])
TypeError: 'str' object is not callable</module></pyshell>

先不管sum([1,2,3,4])的意义，它的作用是把1/2/3/4加在一起得到10，然后错误的给一个变量也取了个sum的标识符名称，再后面又调用sum([1,2,3,4])的时候，程序抛出异常，错误原因是str不是可调用的类型。归根到底就是sum这个名字重名了的原因。

数据类型

简单来说，数据类型是一种表示值的方式。在我们的现实世界中，我们将字母、数字、符号作为不同类型的常用值。同样，Python 包含以下基本数据类型：

• int（整数）

• float（浮点数）

• str（字符串）

• bool（布尔值）

• list（列表）

• tuple（元祖）

• set（集合）

• dict（字典）

• complex（复数）

• None（空值）

这些是 Python 中可用的标准数据类型。要创建我们自己的自定义类型，需要使用类。也可以通过导入外部库或模块来使用专门的数据类型。

相反，在 JavaScript 中，有以下可用的原始类型：

• number （数字：整数和小数）

• string（字符串）

• boolean（布尔值）

• symbol（符号：唯一、不可变）

• bigInt（大整数）

• null（空值）

• undefined（对象也是非原始类型）

今天我只是花时间整理 Python 的数字和字符串类型。

数字

有 3 种数字数据类型：

• int（存储无限大小的整数）

• float（存储浮点实数值）

• complex（我现在只是跳过它，因为我了解到它不常用，类似于 JavaScript 中的 bigInt）。

相比之下，JavaScript 有两种数值数据类型，Number和BigInt。
type函数用于确定值或表达式的类型。（类似于 JavaScript中的typeof运算符）

num = 100 # variable assignement
    print(type(num)) # <class>

    num2 = 99.99
    print(type(num2)) # <class>

    expression1 = num * 10
    print(type(expression1)) # <class>

    expression2 = num + num2
    print(type(expression2)) # <class></class></class></class></class>

在 Python 中，变量赋值是通过编写名称并使用=运算符赋值来实现的。
在 JavaScript 中，变量名需要以var,const或let关键字开头。

数学计算

对于数学计算，除了前面提到过的简单的加减乘除等等，更多的科学计算需要导入math

Ils sont sensibles à la casseVous ne pouvez pas nommer directement les variables de mots-clés (voir la documentation officielle "Python Keywords")

Alors, que se passera-t-il si vous faites vraiment cette erreur ? Par exemple : 🎜

print(round(2.1)) # 2
    print(round(5.9)) # 6
    print(abs(-34)) # 34

Vous voyez ? Invitez directement les erreurs de syntaxe. 🎜

En plus de ne pas utiliser de mots-clés comme identifiants, comme nous l'avons souligné précédemment, les identifiants portant le même nom que les fonctions intégrées ne peuvent pas être utilisés. Python a de nombreuses fonctions intégrées. Prenons sum comme exemple. Il s'agit d'une fonction de sommation. Examinons les conséquences d'une dénomination incorrecte : 🎜

>>> math.log(2)
0.6931471805599453
>>> math.cos(30)
0.15425144988758405
>>> math.cos(60)
-0.9524129804151563
>>> math.sin(30)
-0.9880316240928618
>>> math.sin(math.degrees(30))
-0.4097717985741408
>>> math.sin(math.radians(30))
0.49999999999999994

Ignorons sum([ 1, 2,3,4]), sa fonction est d'additionner 1/2/3/4 pour obtenir 10, puis de donner par erreur à une variable le nom d'identification de sum, puis d'appeler sum( [1,2,3 ,4]), le programme lève une exception. La raison de l'erreur est que str n'est pas un type appelable. En dernière analyse, c'est la raison pour laquelle la somme des noms est dupliquée. 🎜

Type de données 🎜

En termes simples, un type de données est un moyen de représenter une valeur. Dans notre monde réel, nous avons des lettres, des chiffres et des symboles comme différents types de valeurs communes. De même, Python contient les types de données de base suivants : 🎜

🎜🎜int (entier) 🎜🎜🎜🎜float (nombre à virgule flottante) 🎜🎜 🎜🎜 str (chaîne) 🎜🎜🎜🎜bool (booléen) 🎜🎜🎜🎜list (liste) 🎜🎜🎜🎜tuple (tuple) 🎜🎜🎜🎜set (set) 🎜🎜🎜🎜dict (dict) 🎜🎜🎜 🎜 complexe (pluriel) 🎜🎜🎜🎜Aucun (valeur nulle) 🎜🎜

Ce sont les types de données standard disponibles en Python. Pour créer nos propres types personnalisés, nous devons utiliser des classes. Des types de données spécialisés peuvent également être utilisés en important des bibliothèques ou des modules externes. 🎜

En revanche, en JavaScript, les types primitifs suivants sont disponibles : 🎜

🎜🎜 number (nombre : entier et décimal) 🎜🎜🎜🎜string (chaîne) 🎜🎜🎜🎜boolean (booléen) 🎜🎜🎜🎜symbol (symbole : unique, immuable) 🎜🎜🎜🎜bigInt (grand entier) 🎜🎜 + Le numérique de Python et les types de chaînes. 🎜

Nombres 🎜

Il existe 3 types de données numériques : 🎜

🎜🎜int (stocke des entiers de taille infinie) 🎜🎜🎜🎜float (stocke les valeurs réelles à virgule flottante) 🎜🎜🎜🎜complexe (je le saute maintenant parce que j'ai appris que c'est moins couramment utilisé et est similaire à bigInt en JavaScript). 🎜🎜

En revanche, JavaScript a deux types de données numériques, Number et BigInt. La fonction
type est utilisée pour déterminer le type d'une valeur ou d'une expression. (Similaire à l'opérateur typeof en JavaScript) 🎜

name = 'Python' # string assignment within single quotes
    name2 = "Python" # string assingment within double quotes
    name3 = '''This is a a very long string and supports 
            multiline statements as well''' # string assingment within 3 single quotes
    name4 = 'Hello! \"Rockstar Programmer\"' # string with escaped character sequence
    print(type(name)) # <class>
    print(type(name2)) # <class>
    print(type(name3)) # <class>
    print(type(name4)) # <class></class></class></class></class>

En Python, l'affectation de variable est Ceci est accompli en écrivant un nom et en l'attribuant à l'aide de l'opérateur =.
En JavaScript, les noms de variables doivent commencer par les mots-clés var, const ou let. 🎜

Calculs mathématiques

Pour les calculs mathématiques, en plus de ceux mentionnés précédemment Addition simple, soustraction, multiplication et division, etc., des calculs plus scientifiques doivent importer la bibliothèque math, qui contient la plupart des fonctions de calcul scientifique dont nous pourrions avoir besoin, comme indiqué dans le tableau ci-dessous. Certaines fonctions mathématiques intégrées nous permettent de calculer facilement diverses opérations mathématiques. 🎜🎜🎜🎜🎜🎜🎜🎜🎜🎜fonction🎜

Valeur de retour (Description)

abs(x)

renvoie la valeur absolue du nombre, comme abs(-10) renvoie 10

ceil(x)

Renvoie l'entier ascendant du nombre, tel que math.ceil(4.1) renvoie 5

exp(x)

Renvoie la puissance x de e (ex), tel que math.exp (1) renvoie 2,718281828459045

fabs(x)

renvoie la valeur absolue du nombre, comme math.fabs(-10) renvoie 10,0

floor(x)

renvoie l'entier arrondi du nombre. Par exemple, math.floor(4.9) renvoie 4

log(x)

Si math.log(math.e) renvoie 1,0, math.log (100,10) renvoie 2,0

log10(x)

Renvoie le logarithme de x en base 10, tel que math.log10(100) renvoie 2,0

max(x1, x2,...)

renvoie La valeur maximale d'un paramètre donné, qui peut être une séquence.

min(x1, x2,...)

Renvoie la valeur minimale du paramètre donné, qui peut être une séquence.

modf(x)

Renvoie la partie entière et la partie décimale de x Les signes numériques des deux parties sont les mêmes que x, et la partie entière est exprimée en type à virgule flottante.

pow(x, y)

x**y valeur après opération.

round(x [,n])

Renvoie la valeur arrondie du nombre à virgule flottante x Si la valeur n est donnée, elle représente le nombre de chiffres arrondis à la virgule décimale.

sqrt(x)

Renvoie la racine carrée du nombre x

acos(x)

Renvoie l'arc cosinus de x en radians.

asin(x)

Renvoie l'arc sinus de x valeur.

atan(x)

Renvoie le radian arctangent de x valeur.

atan2(y, x)

Renvoie le donné arctangente des valeurs des coordonnées X et Y.

cos(x)

Renvoie le cosinus de l'arc de valeur x.

hypot(x, y)

Retour à Euclide allemand norme sqrt(xx + yy)

sin(x)

#🎜 🎜#

Renvoie le sinus de x radians.

tan(x)

Renvoie la valeur tangente de x radians.

degrees(x)

Convertir des radians en degrés, Pour exemple, les degrés (math.pi/2) renvoie 90,0 🎜#

Convertir les angles en radians

print(round(2.1)) # 2
    print(round(5.9)) # 6
    print(abs(-34)) # 34

以及两个数学常量：

常量	描述
pi	数学常量 pi（圆周率，一般以π来表示）
e	数学常量 e，e即自然常数（自然常数）。

下面是一些应用展示，注意最后的角度调用方式：

>>> math.log(2)
0.6931471805599453
>>> math.cos(30)
0.15425144988758405
>>> math.cos(60)
-0.9524129804151563
>>> math.sin(30)
-0.9880316240928618
>>> math.sin(math.degrees(30))
-0.4097717985741408
>>> math.sin(math.radians(30))
0.49999999999999994

字符串

字符串是Python中最常用的数据类型之一，使用单引号或双引号来创建字符串，使用三引号创建多行字符串。字符串要么使用两个单引号，要么两个双引号，不能一单一双！Python不支持单字符类型，单字符在Python中也是作为一个字符串使用。

字符串是不可变的序列数据类型，不能直接修改字符串本身，和数字类型一样！Python3全面支持Unicode编码，所有的字符串都是Unicode字符串，所以传统Python2存在的编码问题不再困扰我们，可以放心大胆的使用中文。

name = 'Python' # string assignment within single quotes
    name2 = "Python" # string assingment within double quotes
    name3 = '''This is a a very long string and supports 
            multiline statements as well''' # string assingment within 3 single quotes
    name4 = 'Hello! \"Rockstar Programmer\"' # string with escaped character sequence
    print(type(name)) # <class>
    print(type(name2)) # <class>
    print(type(name3)) # <class>
    print(type(name4)) # <class></class></class></class></class>

>>> var1 = 'Hello World!'
>>> var2 = "Jack"
>>> var3 = ""                   # 空字符串
>>> var4 = "it's apple"         # 双引号中可以嵌套单引号
>>> var5 = 'This is "PLANE"!'   # 单引号中可以嵌套双引号
>>> var6 = 'what is 'your'name'
SyntaxError: invalid syntax

但是单引号嵌套单引号或者双引号嵌套双引号就会出现歧义。

>>> a = "haha"
>>> b = a
>>> a = "xixi"
>>> a is b
False
>>> a[1] = "z"
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
    a[1] = "z"
TypeError: 'str' object does not support item assignment</module></pyshell>

虽然字符串本身不可变，但可以像列表序列一样，通过方括号加下标的方式，访问或者获取它的子串，当然也包括切片操作。这一切都不会修改字符串本身，当然也符合字符串不可变的原则。

>>> s = "hello world!"
>>> s[4]
'o'
>>> s[2:6]
'llo '
>>> s
'hello world!'

字符串连接

与 Javascript 类似，可以使用+运算符连接字符串。它只是连接或“连接”字符串。

first_name = 'Mike'
    last_name = 'Tyson'
    print(first_name + ' ' + last_name) # Mike Tyson

类型转换

与存在隐式类型转换（又名强制类型转换）的 Javascript 不同，如果使用不同类型执行操作，Python 将抛出错误：

user_name = 'John'
    age = 40
    print(user_name + age) # TypeError: can only concatenate str (not "int") to str
    # This would work in Javscript where it would convert the result to string type

在 Python 中，需要显式转换类型才能执行不同类型的操作：

user_name = 'John'
    age = 40
    print(user_name + str(age)) # John40
    print(type str(age)) # <class></class>

同样，字符串也可以转换为数字：

lucky_number = 7
    lucky_number_stringified = str(7)
    lucky_number_extracted = int(lucky_number_stringified)
    print(lucky_number_extracted) # 7

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!