Heim >Backend-Entwicklung >Python-Tutorial >Vermittlung von Python-Grundkenntnissen

Vermittlung von Python-Grundkenntnissen

巴扎黑Original: 2017-06-23 15:33:292341Durchsuche

Abschnitt 1 Python-Dateitypen

Quellcode

Python-Quellcodedateien haben die Erweiterung „py“ und werden vom Python-Programm interpretiert und erfordern keine Kompilierung

Byte-Code

Die Datei mit der Erweiterung „pyc“, die nach der Kompilierung der Python-Quelldatei generiert wird

Kompilierungsmethode

import py_compile
py_compile.compile("hello.py")

Optimierter Code

Optimierte Quelldatei mit der Erweiterung „.pyo“
python -O -m py_compile hello.py

Alle drei oben genannten können direkt ausgeführt werden

Python-Variablen im zweiten Abschnitt

Definition von Variablen

Eine Variable ist ein Bereich im Computerspeicher. Variablen können Werte innerhalb eines bestimmten Bereichs speichern und die Werte können geändert werden.

Variablenbenennung

Variablennamen bestehen aus Buchstaben, Zahlen und Unterstrichen.
Zahlen dürfen nicht mit
Schlüsselwörter können nicht verwendet werden
a a1 a_ a_1
beginnen

Zuweisung von Variablen

ist der Prozess der Variablendeklaration und -definition
```
a = 1
ld(a)
```

Abschnitt 3 Operatoren und Ausdrücke

Fall: Schreiben Sie Ihre eigenen vier arithmetischen Operatoren

#!/usr/bin/python

import sys
running = True

while running:
    try:
        t = int(raw_input())
        p = int(raw_input())
    except EOFError:
        break

    print 'operator + result\n', t + p
    print 'operator - result\n', t - p
    print 'operator * result\n', t * p
    print 'operator / result\n', t / p

Python-Operatoren umfassen

Zuweisung Operatoren

x = 3, y = 'abcde'      #等于
x += 2                  #加等于
x -= 2                  #减等于
x *= 2                  #乘等于
x /= 2                  #除等于
x %= 2                  #求余等于

Arithmetische Operatoren

x + y                   #加法
x - y                   #减法
x * y                   #乘法
x / y                   #实数除法
x // y                  #整数除法
x % y                   #求余
x**y                    #求幂

Relationale Operatoren

x < y                   #大于
x > y                   #小于
x <= y                  #小于等于
x >= y                  #大于等于
x != y                  #不等于
x == y                  #完全等于

Logische Operatoren

and                     #与
or                      #或
not                     #非

Ausdruck

Ausdruck besteht darin, verschiedene Daten (einschließlich Variablen, Funktionen) zu kombinieren. Eine Formel, die durch Operatoren nach bestimmten Kriterien verbunden wird Regeln

Die Priorität des Operators

In regulären Ausdrücken gibt es Mit mehreren Operatoren, wie zum Beispiel: 1+2*3-1/2*3/2, dann gibt es die Problem der Prioritätsberechnung
Im Allgemeinen haben Operatoren hohe und niedrige Prioritätsebenen. Im gleichen Ausdruck sind die Prioritätsoperatoren hoher Ebene: Zum Beispiel: 1*2+3*3 = 11 statt 15
Bei Operatoren derselben Ebene erfolgt die Abarbeitung von links nach rechts. Zum Beispiel: 8*4/2*3 = 48

Die Operatorpriorität von niedrig nach hoch ist:

Lambda
逻辑或：or
逻辑与：and
逻辑非：not
成员测试：in      not in
同一性测试：is      is not
比较：<   <=  >   >=  !=  ==
按位或：|
按位异或：^
按位与：&
移位：<<  >>
加法与减法：+   -
乘法、除法与取余：*   /   %
正负号：+x  -x
按位翻转：~x
指数：**

Abschnitt 4 Datentyp

Fall

123 Ist es dasselbe wie "123"
() [] {}

Datentyp

Computer werden zur Unterstützung von Menschen verwendet, und reale Klassifizierungen werden auch in der Programmierung abgebildet, um abstrakte Analysen zu ermöglichen.
Nummer
Zeichenfolge
Liste
Tupel
Wörterbuch

Zahlentyp

Ganzzahl
Long
Gleitkomma
Pluraltyp

Numerischer Typ – Ganzzahl int

Der durch die Ganzzahl int dargestellte Bereich liegt zwischen -2147483648 und 2147483647. Zum Beispiel: 0, 100, -100

Bereichsbeispiel für int:

num=2147483647
type(num)       #输出结果: <type &#39;int&#39;>

Zahlentyp – Long Integer Long

Der Bereich von long ist sehr groß. Man kann sagen, dass fast jede große Ganzzahl gespeichert werden kann.
Um zwischen gewöhnlichen Ganzzahlen und langen Ganzzahlen zu unterscheiden, müssen Sie nach der Ganzzahl ein L oder ein kleines l hinzufügen. Zum Beispiel: 51856678L, -0x22345L
```
num = 11
type(num)       #输出结果: <type &#39;int&#39;>
num = 9999999999999999999999
type(num)       #输出结果: <type &#39;long&#39;>
```

Zahlentyp – Gleitkomma-Float

Zum Beispiel: 0.0, 12.0, -18.8, 3e+7

Beispiel:

num = 0.0
type(num)       #输出结果: <type &#39;float&#39;>
num = 12
type(num)       #输出结果: <type &#39;int&#39;>
num = 12.0
type(num)       #输出结果: <type &#39;float&#39;>

Zahlentyp – komplexer Zahlentyp komplex

Python bietet integrierte Unterstützung für komplexe Zahlen, die in den meisten anderen Programmen nicht verfügbar sind
Pluralbeispiel: 3.14j, 8.32e-36j

Beispiel:

>>> num=3.14j
>>> type(num)
<type &#39;complex&#39;>
>>> num
3.14j
>>> print num
3.14j

String String

Eine durch Anführungszeichen definierte Menge, die Zahlen, Buchstaben und Symbole (nicht spezielle Systemsymbole) enthalten kann.
```
Strval='This is a test'
Strval="This is a test"
Strval="""This is a test"""
```
Dreifache Anführungszeichen (docstring) werden normalerweise zum Erstellen von Zeichenfolgen verwendet, ausführliche Erklärung in objektorientierter

Abschnitt 5 Sequenzen

Grundkonzepte

Listen, Tupel und Zeichenfolgen sind alle Sequenzen
Sequenzen Die Zwei Hauptfunktionen sind der Indexierungsoperator und der Slicing-Operator.

Der Indexoperator ermöglicht es uns, ein bestimmtes Element aus einer Sequenz auszuwählen.
Der Slice-Operator ermöglicht es uns, ein Slice einer Sequenz, also einen Teil einer Sequenz, zu erhalten.

Der Index kann auch eine negative Zahl sein und die Position wird ab dem Ende der Sequenz berechnet.

Daher stellt shoplist[-1] das letzte Element der Sequenz dar, während shoplist[-2] das vorletzte Element der Sequenz erfasst

Der Slicing-Operator ist der Sequenzname, gefolgt von einer eckigen Klammer mit einem optionalen Zahlenpaar, getrennt durch einen Doppelpunkt.

shoplist[1:3]返回从位置1开始，包括位置2，但是停止在位置3的一个序列切片，因此返回一个含有两个项目的切片。shoplist[:]返回整个序列的拷贝。你可以用负数做切片。负数用在从序列尾开始计算的位置。例如,shoplist[:-1]会返回除了最后一个项目外包含所有项目的序列切片
注意这与你使用的索引操作符十分相似。记住数是可选的，而冒号是必须的。
切片操作符中的第一个数（冒号之前）表示切片开始的位置，第二个数（冒号之后）表示切片到哪里结束。如果不指定第一个数，Python就从序列首开始。如果没有指定第二个数，则Python会停止在序列尾。
注意：返回的序列从开始位置开始，刚好在结束位置之前结束。即开始位置是包含在序列切片中的，而结束位置被排斥在切片外。

序列的基本操作

len()：求序列的长度
+：连接两个序列
*：重复序列元素
in：判断元素是否在序列中
max()：返回最大值
min()：返回最小值
cmp(tuple1, tuple2)：比较两个序列值是否相同

元组()

元组和列表十分类似，只不过元组和字符串一样是不可变的，即你不能修改元组。

元组通过圆括号中用逗号分割的项目定义。
元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候，即被使用的元组的值不会改变。

创建元组

一个空的元组由一对空的圆括号组成，如：myempty=()
含有单个元素的元组，singleton=(2)

一般的元组

zoo=('wolf', 'elephant', 'penguin')
new_zoo=('monkey', 'dolphin', zoo)

元组操作

元组和字符串一样属于序列类型，可通过索引和切片操作。
元组值亦不可变

第六节序列-列表

列表[]

list是处理一组有序项目的数据结构，即你可以在一个列表中存储一个序列的项目。
列表是可变类型的数据。
列表的组成：用[]表示列表，包含了多个以逗号分隔开的数字，或者子串。
```
list1=['Simon', 'David', 'Clotho']
list2=[1,2,3,4,5]
list3=["str1", "str2", "str3", "str4"]
```

列表操作

取值

切片和索引
list[]

添加

list.append()

删除

del(list[])
list.remove(list[])

修改

list[]=x

查找

var in list

示例：

>>> list1=['jack', 20, 'male']
>>> list1
['jack', 20, 'male']
>>> list1.append('USA')
>>> list1
['jack', 20, 'male', 'USA']
>>> list1.remove('USA')
>>> list1
['jack', 20, 'male']
>>> help(list1.remove)
>>> list1[1]=22
>>> list1
['jack', 22, 'male']
>>> 22 in list1
True

对象与类快速入门

对象和类，更好的理解列表。
对象=属性+方法
列表是使用对象和类的一个例子

当你使用变量i并给它赋值时候，比如整数5，你可以认为你创建了一个类（类型）int的对象（实例）i。
help(int)

类也有方法，即仅仅为类而定义的函数。

Python为list类提供了append方法，这个方法让你在列表尾添加一个项目。
mylist.append('an item')列表mylist中增加字符串。注意，使用点号来使用对象的方法。
仅在该类的对象可以使用这些功能。
例如：

类也有变量，仅为类而定义的变量

仅在该类的对象可以使用这些变量/名称
通过点号使用，例如mylist.field。

第七节字典

基本概念

字典是Python中唯一的映射类型（哈希表）。
字典对象是可变的，但是字典的键必须使用不可变的对象，并且一个字典中可以使用不同类型的键值。
keys()或者values()返回键列表或值列表。
items()返回包含键值对的元值。

示例：

>>> dict={'name': 'jack', 'age' : 30, 'gender':'male' }
>>> dict['name']
'jack'
>>> dict['age']
30
>>> dict['gender']
'male'
>>> dict.keys()
['gender', 'age', 'name']
>>> dict.values()
['male', 30, 'jack']
>>> dict.items()
[('gender', 'male'), ('age', 30), ('name', 'jack')]

创建字典

dict = {}
使用工厂方法dict()
```
fdict=dict(['x',1], ['y',2])
```
内建方法：fromkeys()，字典中的元素具有相同的值，默认为None
```
ddict={}.fromkeys(('x','y'), -1)
#输出结果：{'x': -1, 'y': -1}
```

访问字典中的值

直接使用key访问：key不存在会报错，可以使用has_key()或者in和not in判断，但是has_key方法即将废弃。
循环遍历：for key in dict1.keys():
使用迭代器：for key in dict1:

更新和删除

直接用键值访问更新；内建的update()方法可以将整个字典的内容拷贝到另一个字典中。
del dict1['a']：删除字典中键值为a的元素
dict1.pop('a')：删除并且返回键为'a'的元素
dict1.clear()：删除字典所有元素
del dict1：删除整个字典

字典相关的内建函数

type(), str(), cmp()(cmp很少用于字典的比较，比较依次是字典的大小、键、值)

工厂函数dict()

*　例如：

dict(zip(('x','y'),(1,2)))
dict(x=1,y=2)
#输出结果：{'x': 1, 'y': 2}

使用字典生成字典比用copy慢，因此这种情况下推荐使用copy()

常用函数

len()：返回序列的大小
hash() : 用于判断某个对象是否可以做一个字典的键，非哈希类型报TypeError错误
dict.clear():　删除字典中的所有元素
dict.fromkeys(seq, val=None): 以seq中的元素为键创建并返回一个字典，val为制定默认值
dict.get(key, default=None): 返回key的value，如果该键不存在返回default指定的值
dict.has_key(key)：判断字典中是否存在key，建议使用in或not in代替
dict.items()：返回健值对元组的列表
dict.keys()：返回字典中键的列表
dict.iter*(): iteritems(), iterkeys(), itervalues()返回迭代子而不是列表
dict.pop(key[,default])：同get()，区别是若key存在，删除并返回dict[key]，若不存在则返回default，未指定值，抛出KeyError异常
dict.setdefault(key, default=None)：同set()，若key存在则返回其value，若key不存在，则dict[key]=default
dict.update(dict2)：将dict2中的键值对添加到字典dict中，如果有重复则覆盖，原字典不存在的条目则添加进来。
dict.values()：返回字典中所有值的列表

第八节流程控制

if else

if语句

一个字符串是否为空的
一个运算结果是否为零
一个表达式是否可用
True：表示非空的量（比如：string, tuple, set, dictonary等），所有非零数
False：表示0，None，空的量等。
Python的if语句类似其他语言。if语句包含一个逻辑表达式，使用表达式比较，在比较的结果的基础上作用出决定。
```
if expression:
    statement
```
注：Python使用缩进作为其语句分组的方法，建议使用4个空格代替缩进。
逻辑值（bool）用来表示诸如：对与错，真与假，空与非空的概念
逻辑值包含了两个值：
作用：主要用于判读语句中，用来判断

else语句

语法

if expression:
    statement
else:
    statement

如果条件表达式if语句解析为0或false值。else语句是一个可选的语句，并最多只能有一个else语句。

elif语句

语法

if expression:
    statement
elif expression2:
    statement
elif expression3:
    statement
else:
    statement

elif语句可以让你检查多个表达式为真值，并执行一个代码块，elif语句是可选的。可以有任意数量的elif。

嵌套的if...elif...else构造

if expression1:
    statement
    if expression2:
        statement
    else:
        statement
else:
    statement

使用逻辑运算符and、or、not

if expression1 and expression2:
    statement
else:
    statement

for循环

循环是一个结构，导致一个程序重复一定次数。
条件循环也是如此。当条件变为假，循环结束。
for循环：

在Python for循环遍历序列，如一个列表或一个字符。

for循环语法：

for iterating_var in sequence:
    statements

注：如果一个序列包含一个表达式列表，它是第一个执行。
然后，该序列中的第一项赋值给迭代变量iterating_var。接下来，执行语句块。列表中的每个项目分配到iterating_var，代码块被执行，直到整个序列被耗尽。
注：格式遵循代码块缩进原则

例子：

for letter in 'python':
    print 'Current Letter: ', letter

fruits=['banana', 'apple', 'mango']
for fruit in fruits:
    print 'Current fruit: ', fruit

迭代序列指数（索引）：

遍历每个项目的另一种方法是由序列本身的偏移指数（索引）

例子

fruits=['banana', 'apple', 'mango']
for index in range(len(fruits)):
    print 'Current fruit: ', fruits[index]

注：‘迭代’，指重复执行一个指令。

range

循环结构是用于迭代多个项的for语句，迭代形式可以循环序列的所有成员。
range(i,j[,步进值])

如果所创建的对象为整数，可以用range
i为初始数值
j为终止数值，但不包括在范围内，步进值为可选参数，不选的话默认是1
i不选择的话默认为0

例子：

sum = 0
for num in range(1, 101, 1):
    sum += num
print sum

遍历字典

    dic={'name': 'jack', 'age': 20, 'gender'：'male'}
    for key in dic:
        val = dic[key]
        print key,val

    for key,val in dic.items():
        print key, val

for循环控制

    for x in range(10):
        if x == 1:
            pass
        if x == 2:
            continue
        if x == 5:
            break;
    else
        print 'end'

while循环

while循环，直到表达式变为假。表达的是一个逻辑表达式，必须返回一个true或false值
语法：
```
while expression:
    statement
```

注：遵循代码块缩进原则

while x != 'q':
    x = raw_input('please input something, q for quit: ')
    if not x:
        break
else:
    print 'end'

Das obige ist der detaillierte Inhalt vonVermittlung von Python-Grundkenntnissen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Stellungnahme：

Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn

Vorheriger Artikel：NLTK-Lernen: Vokabeln klassifizieren und kommentierenNächster Artikel：NLTK-Lernen: Vokabeln klassifizieren und kommentieren

In Verbindung stehende Artikel

Mehr sehen