Ceci est une continuation de la section de construction d'environnement de Dernière fois. Cette fois, nous allons jeter un coup d'œil à la grammaire de Python.
Python est appelé "un langage orienté objet simple et facile à apprendre".
Python a longtemps été utilisé comme langage d'apprentissage de la programmation, Récemment, il a été utilisé comme moteur Google App, et il existe de nombreux plug-ins pour l'apprentissage automatique et la manipulation de données, il a donc attiré beaucoup d'attention. (Au Japon, ce n'est pas si perceptible, mais cela semble être très populaire à l'étranger.)
Cette fois, j'aimerais revoir la grammaire en utilisant le Python 2.7.x largement utilisé. (Utilisez 2.7.12.)
Les points-virgules à la fin des phrases sont obsolètes dans la syntaxe Python. (Il est défini dans pep8, qui sera expliqué dans les articles suivants et suivants.) La fin de la phrase est représentée par un saut de ligne.
Vous pouvez commenter avec \ #.
Lorsque je mets des caractères japonais dans le code en Python, l'erreur suivante est générée.
File "index.py", line 2
SyntaxError: Non-ASCII character '\xe3' in file index.py on line 2, but no encoding declared; see http://python.org/dev/peps/pep-0263/ for
details
Lorsqu'il s'agit de japonais dans le code, UTF-8 doit être explicitement déclaré.
# coding: UTF-8
#Ci-dessus, vous pouvez utiliser le japonais sur le code
print 'hello' #Salut bonjour
Il peut être déclaré sans préfixe spécial.
msg = 'hello from gemcook'
print msg
Les types de données qui peuvent être gérés par Python sont les suivants.
--Valeur numérique
Lorsque vous calculez une fraction et un entier, cela devient une fraction.
Si vous divisez les entiers, vous obtiendrez le résultat de la troncature.
print 10 / 3 # 3
Si vous souhaitez obtenir un petit nombre, vous pouvez procéder comme suit.
print 10 / 3.0 # 3.3333333333
Sortie avec "u" (unicode) au début de la chaîne de caractères. (Sans u, les résultats corrects ne seront pas obtenus lors de la recherche de chaînes.)
print 'hello' + 'world' # helloworld
print u'Est' *5 # EstEstEstEstEst
Décrivez avec \.
print 'It\'s a pen!'
Si vous l'entourez entre '' 'et' '', la plage sera interrompue et forcée à s'échapper si elle se brise.
print '''
<html lang="ja">
<body>
</body>
</html>
'''
s = 'abcdefghi'
print len(s) # 9
print s.find('c') # 2(Si ça n'existe pas-Renvoie 1)
print s[2] # c
print s[2:5] # cde(Retourne jusqu'au 5ème précédent)
print s[2:] # cdefghi
print s[:5] # abcde
print s[2:-1] # cdefgh(Renvoie jusqu'à un avant le dernier caractère)
Dans d'autres langues telles que JS, les caractères numériques sont automatiquement convertis en valeurs numériques. («1» est jugé égal à 1)
Puisque Python n'effectue pas automatiquement la conversion de type, il est nécessaire d'effectuer une conversion de type explicitement.
print 5 + '5' #Une erreur se produira.
Si vous souhaitez le convertir en entier, procédez comme suit.
print 5 + int('5') # 10
La même chose s'applique aux chaînes de caractères.
age = 20
print 'i am ' + str(age) + ' years old'
Dans d'autres langues, cela s'appelle un tableau.
sales = [
255,
100,
353
]
Le contenu de la liste peut être affecté à tout type d'élément.
sales = [
255,
100,
353,
'apple'
]
Vous pouvez utiliser les mêmes instructions pour les listes que pour les chaînes.
sales = [
255,
100,
353,
'apple'
]
sales2 = [
500,
'orange'
]
print sales # [255, 100, 353, 'apple']
print sales * 2 # [255, 100, 353, 'apple', 255, 100, 353, 'apple']
print sales + sales2 # [255, 100, 353, 'apple', 500, 'orange']
print len(sales) # 4
print sales[3] # 'apple'
sales[2] = 250
print sales # [255, 100, 250, 'apple']
Il existe également une commande de contrôle d'existence.
sales = [
255,
100,
353,
'apple'
]
print 100 in sales # True
Il y a aussi une instruction pour faire une liste de numéros de série.
print range(3) # [0, 1, 2]
print range(1, 3) # [1, 2]
print range(3, 10, 2) # [3, 5, 7, 9]
list est une variable de type liste et str est une variable de type chaîne de caractères.
d = '2013/12/15'
print d.split('/') # [2013, 12, 15]
list = ['a', 'b', 'c']
print string.join(list)
Le taple est fondamentalement le même que la liste. Cependant, il a la particularité que les éléments ne peuvent pas être modifiés.
Vous pouvez utiliser les mêmes instructions que les tableaux.
tuple1 = (2, 5, 8)
tuple2 = (5, 5, 5)
print tuple1 + tuple2 # (2, 5, 8, 5, 5, 5)
print 2 in tuple2 # True
tuple1[2] = 10 #Cela entraînera une erreur.
Il est possible de basculer de manière flexible entre tapple et list en utilisant la commande de conversion de type, qui est identique à la conversion entre les chaînes de caractères et les nombres.
array = [
'dog',
'cat',
'tiger'
]
print array # ['dog', 'cat', 'tiger']
tupleChange = tuple(array)
listChange = list(tupleChange)
print tupleChange # ('dog', 'cat', 'tiger')
print listChange # ['dog', 'cat', 'tiger']
En plus d'enseigner que les données ne peuvent pas être modifiées explicitement, la signification de l'utilisation Cela conduit également à une amélioration de la vitesse de traitement.
Lorsque le taple est disponible, utilisez le taple.
L'ensemble est le même que la liste et taple, et les données sont alignées, Il a la particularité de ne pas permettre la duplication.
Vous pouvez calculer l'ensemble tel qu'il est appelé le type d'ensemble.
a = set([1, 2, 3])
b = set([3, 4, 5])
De plus, les données en double seront ignorées.
print set([1, 2, 3, 3, 3, 4, 5]) # set([1, 2, 3, 4, 5])
# coding: UTF-8
a = set([1, 2, 3, 6])
b = set([3, 4, 5, 7])
#Ensemble de différences(Les choses qui sont dans a mais pas dans b)
print b - a # set([1, 2, 6])
#Ensemble de somme(Que contient a et b)
print a | b # set([1, 2, 3, 4, 5, 6, 7])
#Ensemble de produits(Doublons en a et b)
print a & b # set([3])
#Un seul parmi a et b
print a ^ b # set([1, 2, 4, 5, 6, 7])
C'est un objet dans JS. Je pense que le type de dictionnaire Swift est plus proche de l'image.
mugiwara = {
'luffy': 100000000,
'zoro': 77000000
}
print mugiwara # {'zoro': 77000000, 'luffy': 100000000}
Notez que les éléments de sortie ne sont pas dans un ordre particulier.
En ce qui concerne l'affectation et l'acquisition, ce n'est pas différent d'une liste.
mugiwara = {
'luffy': 100000000,
'zoro': 77000000
}
print mugiwara['luffy'] # 100000000
mugiwara['zoro'] = 120000000
print mugiwara # {'zoro': 120000000, 'luffy': 100000000}
Vous pouvez également vérifier l'existence de la clé avec la commande in.
mugiwara = {
'luffy': 100000000,
'zoro': 77000000
}
print 'luffy' in mugiwara # True
Il s'agit d'une méthode unique au type de dictionnaire.
mugiwara = {
'luffy': 100000000,
'zoro': 77000000
}
#Obtenez une liste de clés.
print mugiwara.keys() # ['zoro', 'luffy']
#Obtenez une liste de valeurs.
print mugiwara.values() # [77000000, 100000000]
# key-Obtenez une liste de valeurs.
print mugiwara.items() # [('zoro', 77000000), ('luffy', 100000000)]
Il est également possible d'incorporer d'autres types dans un type chaîne sans avoir à se soucier d'effectuer une conversion de type.
a = 3000000000
b = 1.234
c = 'luffy'
d = {
'choppa': 50,
'usoppu': 300000000
}
#Incorporer des valeurs entières
print 'decimal: %010d' % a # 3000000000
#Incorporer des nombres décimaux
print 'float: %.1f' % b # 1.2
#Incorporer une chaîne
print 'name: %s' % c # luffy
#Incorporer le type de dictionnaire
print 'berry: %(choppa)d' % d # 30000000
#Incorporer plusieurs valeurs
print '%s: %d' % (c, a) # luffy: 300000000
--Représenté par% d (décimal)
--Représenté par% f (float)
--Représenté par% s (chaîne)
-% ([keyName]) Représenté par [caractère de type valeur].
--Il est également possible d'attribuer plusieurs valeurs.
La vérification du type Python est la suivante.
score = 70
print type(score) # <type, int>
Vous pouvez également revenir avec True / False.
score = 70
print isinstance(score, int) # True
print isinstance(score, str) # False
Utilisez si comme d'habitude. L'expression conditionnelle () n'est pas obligatoire. Le traitement après l'évaluation de la condition est exprimé par indentation.
# coding: UTF-8
score = 70
if 60 < score < 80:
print 'ok' # 'ok'
Un opérateur de comparaison.
=
Les opérateurs logiques sont plus intuitifs. (Avec JS&&, ||, !)
L'instruction if else est presque la même que les autres langues. Gardez à l'esprit que seul elif est un peu caractéristique.
score = 70
if int(score) > 60:
print 'ok'
elif score > 40:
print 'soso'
else:
print 'ng'
Dans la plupart des langues, il existe un moyen de dessiner une branche conditionnelle sur une ligne. (Opérateur ternaire JS, etc.)
Le branchement conditionnel est un peu délicat dans une ligne de Python, Mémorisons-le pour écrire du code simple.
score =70
print 'ok' if score > 60 else 'ng'
Vous pouvez utiliser l'instruction for. La syntaxe est la suivante.
sales = [13, 3523, 31, 238]
result = 0
for sale in sales:
result += sale
else:
print result
Ce qui suit est un processus qui n'est exécuté qu'une seule fois lorsque la répétition est terminée.
range()
Si vous souhaitez simplement afficher un numéro de série de numéros, vous pouvez utiliser range ().
for i in range(10):
print i # 0 1 2 3 4 5 6 7 8 9
Utilisez continue et pause pour sauter ou terminer le processus de boucle.
for i in range(10):
if i == 3:
continue
elif i == 5:
break
Les boucles de type dictionnaire utilisent la fonction iterXXXX ().
# coding: UTF-8
mugiwara = {
'luffy': 300,
'zoro': 100,
'sanji': 50
}
# key,Obtenez les deux valeurs.
for key, value in mugiwara.iteritems():
print 'key: %s, value: %d' % (key, value)
#Obtenez seulement la clé.
for key in mugiwara.iterkeys():
print key
#Obtenez uniquement de la valeur.
for value in mugiwara.itervalues():
print value
Il y a aussi une boucle while.
# coding: UTF-8
n = 0
while n < 10:
print n
n += 1
else:
print 'finish'
C'est une fonction ordinaire. Enregistrez plusieurs processus à la fois.
Utilisez le mot-clé def.
Comme règle de grammaire (pep8), lors de la définition d'une fonction, créez deux lignes vides.
# coding: UTF-8
def sayHello():
print 'hello'
sayHello()
Bien sûr, il est également possible de prendre un argument.
# coding: UTF-8
def sayHello(name, num):
print 'hello, %s.' % name * num
sayHello('Luffy', 2) # hello, Luffy.hello, Luffy.
Réglez la valeur initiale avec = du côté enregistrement. (Dans pep8, il n'y a pas d'espace entre eux.)
# coding: UTF-8
def sayHello(name, num=3):
print 'hello, %s.' % name * num
sayHello('Luffy') # hello, Luffy.hello, Luffy.hello, Luffy.
Il est également possible de spécifier explicitement l'argument du côté exécution.
# coding: UTF-8
def sayHello(name, num=3):
print 'hello, %s.' % name * num
sayHello('Luffy') # hello, Luffy.hello, Luffy.hello, Luffy.
sayHello(num=2, name='Zoro') # hello, Zoro.hello, Zoro.
Si vous utilisez la commande return du côté enregistrement, vous pouvez renvoyer le résultat de la fonction sous forme de valeur simple.
# coding: UTF-8
def sayHello(name='no name'):
return 'hello, %s' % name
print sayHello(name='Nami')
Pour le moment, vous souhaiterez peut-être définir uniquement la fonction réelle et décrire le traitement du contenu ultérieurement. Dans un tel cas, dans d'autres langues, je pense que la fonction vide est définie comme suit. (Au moment de JS)
index.js
#Seule l'entité, la description du contenu n'est pas encore une fonction
function sayHello() {
}
En Python, la fonction n'est pas définie par {}, et la fin de la phrase est exprimée par indentation, donc l'instruction pass n'est préparée que pour définir une fonction vide.
def sayHello2():
pass
print sayHello2() # None
Vous pouvez éviter l'erreur n'est pas définie en utilisant la commande pass.
En Python, les variables d'une fonction ne sont valides que dans la fonction.
# coding: UTF-8
name = 'Luffy'
def sayHello():
name = 'Zoro'
#Pas Zoro
print name # Luffy
map
C'est une instruction pour exécuter une fonction pour chaque élément de la liste. La commande map est exécutée comme suit.
# coding: UTF-8
listItems = [2, 5, 8]
def double(x):
return x * x
map(double, listItems) # [4, 25, 64]
En Python, il est également possible de définir des fonctions anonymes qui ne sont utilisées qu'une seule fois. J'ai défini un lambda qui double simplement la valeur cible avec map.
# coding: UTF-8
listItems = [2, 5, 8]
result = map(lambda x: x * x, listItems)
print result # [4, 25, 64]
Spécifiez n'importe quel argument immédiatement après lambda. (map assigne les éléments de la liste à x un par un.) lambda est une image dans laquelle seule la valeur est renvoyée dans l'instruction return.
# coding: UTF-8
#Comme cliché, prenez l'objet comme argument de classe.
class User(object):
# __init__Est le constructeur JS
#Le premier argument self est toujours requis lors de l'initialisation
def __init__(self, name):
self.name = name
#Lors de l'utilisation de la méthode de propriété de la classe cible dans la fonction
#Prenez soi-même comme premier argument.
def greet(self):
print 'my name is %s' % self.name
bob = User('Bob')
tom = User('Tom')
print bob.name # 'Bob'
bob.greet() # my name is Bob
tom.greet() # my name is Tom
--L'objet de l'argument de classe est spécifié comme un cliché lors de la création d'une classe.
--__init__ est une méthode d'initialisation lorsqu'une classe est instanciée et est préparée par Python.
Lors de l'héritage d'une classe, décrivez le nom de la source héréditaire dans l'argument de la classe.
# coding: UTF-8
class User(object):
def __init__(self, name):
self.name = name
def greet(self):
print 'my name is %s' % self.name
class SuperUser(User):
def shout(self):
print '%s is SUPER!' % self.name
luffy = SuperUser('Luffy')
luffy.shout() # Luffy is SUPER!
Il contient des instructions utiles que Python a préparées à l'avance.
Veuillez vous référer au Site officiel pour connaître les types de modules disponibles.
Il existe trois principaux types de modules que Python prépare.
Modules préparés à l'origine sans utiliser d'instructions d'importation telles que len, split, join
Modules préparés par Python mais non utilisables sans import
Module à utiliser lors de l'importation après l'installation du module avec pip
Voici un exemple d'importation d'un module externe.
# coding: UTF-8
import math
import random
#Importez uniquement le module de date dans le module datetime
from datetime import date
print math.ceil(5.2) # 6.0
for i in range(5):
print random.random()
print date.today() # 2016-10-08
Pour les gros modules tels que datetime, il est possible de ne découper que les pièces nécessaires. Dans ce cas, utilisez la commande from.
Python a une syntaxe unique, mais je pense que c'est fondamentalement facile à retenir et assez lisible. Je pense que c'est une langue agréable à écrire.
La prochaine fois, j'aimerais explorer Django, le framework le plus populaire de Python.
Recommended Posts