[Python-Programmierung (3)] Grundlegende Datentypen

1 Nummerntyp und Bedienung

1.1 Integer-Typ

Ganzzahlentypen stimmen mit dem Konzept der Ganzzahlen in der Mathematik überein. Sie können positiv oder negativ sein, und der Wertebereich ist unbegrenzt.

pow (x, y) Funktion: berechnet X ^Y , wollen Operatoren wie viel zählen

>>> pow(2,100)
1267650600228229401496703205376

Es gibt 4 hexadezimale Darstellungen

• Dezimal: 1010, 99, -217
• Binär, beginnend mit 0b oder 0B: 0b010, -0B101
• Oktal, beginnend mit 0o oder 0O: 0o123, -0O456
• Hexadezimal, beginnend mit 0x oder 0X: 0x9a, -0X89

1.2 Gleitkomma-Typ

Gleitkommatypen stimmen mit dem Konzept der reellen Zahlen in der Mathematik überein

• Der Bereich der Gleitkommawerte und der Dezimalgenauigkeit ist begrenzt, Routineberechnungen können jedoch ignoriert werden
• Der Wertebereich liegt zwischen -10 ³⁰⁷ und 10 ³⁰⁸ und die Genauigkeit zwischen 10 und ¹⁶

Es gibt eine unsichere Mantisse in der Operation zwischen Gleitkommazahlen, keinen Fehler

>>> 0.1 + 0.3
0.4
>>> 0.1 + 0.2
0.30000000000000004

0,1 stellt einen Bruchteil von 53 binär, von etwa 10 ^-16
Binärdarstellung: 0,00011001100110011001100110011001100110011001100110011010
Dezimaldarstellung als: 0,1000000000000000055511151231257827021181583404541015625

Die binäre Darstellung von Dezimalstellen kann unendlich nahe sein, ist jedoch nicht exakt gleich. Das Ergebnis von 0,1 + 0,2 liegt unendlich nahe bei 0,3, es kann jedoch eine Mantisse geben. Unsichere Mantissen treten im Allgemeinen bei ^{10-16 auf} , sodass die Gleichheit von Gleitkommazahlen nicht direkt mit == Vorzeichen beurteilt werden kann

>>> 0.1 + 0.2 == 0.3
False
>>> round(0.1+0.2, 1) == 0.3
True

Runde (x, d): Runde x, d ist die Anzahl der Dezimalkürzungen

Gleitkommazahlen können in wissenschaftlicher Notation ausgedrückt werden, wobei die Buchstaben e oder E als Potenzsymbol mit 10 als Basis verwendet werden. Das Format ist wie folgt:

<a> e <b> * a * 10 ^b

Beispiel: Der Wert 4,3e-3 beträgt 0,0043, der Wert 9,6E5 beträgt 960000,0

Über Python-Gleitkommazahlen müssen Sie Folgendes wissen:

1. Wertebereich und Genauigkeit sind grundsätzlich unbegrenzt
2. Die Operation hat unsichere Mantissenrunde ()
3. Wissenschaftliche Notation

1.3 Komplexer Typ

In Übereinstimmung mit dem Konzept komplexer Zahlen in der Mathematik erhält
z = 1,23e-4 + 5,6e + 89 j
z.real den Realteil, z.imag den Imaginärteil

1.4 Numerischer Operator

Betreiber und Verwendung	Beschreibung
x + y	Plus die Summe von x und y
x - y	Minus, der Unterschied zwischen x und y
x * y	Multiplikation, Produkt von x und y
x / y	Zusätzlich ergibt der Quotient von x und y 10/3 3,3333333333333335
x // y	Ganzzahlige Division, der ganzzahlige Quotient von x und y ist 10 // 3 und das Ergebnis ist 3

Verbesserte Bedienung und Verwendung	Beschreibung
x op = y	Das ist x = x op y, wobei op ein binärer Operator ist
	x + = y ， x - = y ， x * = y ， x / = y ， x // = y ， x% = y ， x ** = y

Es können gemischte Operationen zwischen Typen ausgeführt werden, was zum "breitesten" Typ führt

• Zwischen den drei Typen besteht eine allmählich "verbreiterte" Beziehung:
  Ganzzahl-> Gleitkomma-> Komplex
• Zum Beispiel: 123 + 4.0 = 127.0 (Ganzzahl + Gleitkomma = Gleitkomma)

1.5 Numerische Bedienfunktionen

Funktion und Verwendung	Beschreibung
abs (x)	Absolutwert, der Absolutwert von x abs (-10,01) ergibt 10,01
divmod (x, y)	Quotientenüberschuss (x // y, x% y) gibt gleichzeitig Quotienten und Rest divmod aus (10, 3) Das Ergebnis ist (3, 1)
pow (x, y [, z])	Leistungsüberschuss, (x ** y)% z, [] bedeutet, dass der Parameter z weggelassen werden kann pow (3, pow (3, 99), 10000) Das Ergebnis ist 4587
rund (x [, d])	Rundung, d soll die Anzahl der Dezimalstellen beibehalten, der Standardwert ist 0 Rundung (-10,123, 2) Das Ergebnis ist -10,12
max (x 1 , x 2 ,…, x n )	Maximalwert, Rückgabe des Maximalwerts in x 1 , x 2 ,…, x n , n ist nicht auf max (1, 9, 5, 4, 3) beschränkt. Das Ergebnis ist 9
min (x 1 , x 2 ,…, x n )	Der Mindestwert, Rückgabe des Mindestwerts von x 1 , x 2 ,…, x n , n ist nicht auf min beschränkt (1, 9, 5, 4, 3). Das Ergebnis ist 1
int (x)	Verwandeln Sie x in eine Ganzzahl und verwerfen Sie den Bruchteil int (123.45) ergibt 123; int ("123") ergibt 123
float (x)	Verwandle x in eine Gleitkommazahl, erhöhe den Bruchteil des Floats (12), das Ergebnis ist 12,0; float ("1,23") das Ergebnis ist 1,23
Komplex (x)	Ändern Sie x in eine komplexe Zahl und fügen Sie den Imaginärteil von Komplex (4) hinzu. Das Ergebnis ist 4 + 0j

2 Beispiel: Die Kraft nach oben

Frage 1: Die Potenz von 1 ‰

• 365 Tage im Jahr, jeden Tag 1 ‰ Fortschritt, wie viel kumulativer Fortschritt?
• 365 Tage im Jahr, 1 ‰ pro Tag, wie viel ist noch übrig?

dayfactor = 0.001
dayup = pow(1 + dayfactor, 365)
daydown = pow(1 - dayfactor, 365)
print("向上：{:.2f},向下：{:.2f}".format(dayup, daydown))

Betriebsergebnis:

向上：1.44,向下：0.69

Frage 2: Die Kraft der Arbeitstage

• 365 Tage im Jahr, 5 Arbeitstage in der Woche, 1% Verbesserung jeden Tag
• 365 Tage im Jahr, 2 Ruhetage pro Woche, 1% des täglichen Rückgangs, wie wäre es mit der Kraft dieses Arbeitstages?

dayup = 1.0
dayfactor = 0.01
for i in range(365):
    if i%7 in [6, 0]:
        dayup *= (1 - dayfactor)
    else:
        dayup *= (1 + dayfactor)
print("工作日的力量：{:.2f}".format(dayup))

Betriebsergebnis:

工作日的力量：4.63

Frage 3: Arbeitsaufwand

• Welcher Aufwand muss im Arbeitstagmodell unternommen werden, um 1% pro Tag zu entsprechen?
• Jun A: 365 Tage im Jahr, 1% Fortschritt jeden Tag, ohne Unterbrechung
• Jun B: 365 Tage im Jahr, 5 Tage die Woche arbeiten und 2 Tage frei nehmen. Der Ruhetag sinkt um 1%. Wie viel Aufwand benötigen Sie?

Wir wenden hier eine dumme Methode an, ein wenig Versuch, beginnend mit 0,01, jedes Mal um 0,001 erhöht, um zu sehen, wann und 1% Fortschritt jeden Tag, das gleiche Maß an Non-Stop-Fortschritt.

def dayUP(df):
    dayup = 1.0
    for i in range(365):
        if i%7 in [0, 6]:
            dayup *= (1 - 0.01)
        else:
            dayup *= (1 + df)
    return dayup;
dayfactor = 0.01
while dayUP(dayfactor) < 37.78:
    dayfactor += 0.001
print("工作日的努力参数是：{:.3f}".format(dayfactor))

Betriebsergebnis

工作日的努力参数是：0.019

3 Zeichenfolgentypen und Operationen

3.1 Darstellung des Stringtyps

Es gibt 4 Arten der Darstellung in 2 Arten von Zeichenfolgen

• Die Zeichenfolge wird durch ein Paar einfacher Anführungszeichen oder ein Paar doppelter Anführungszeichen dargestellt.
• Dargestellt durch ein Paar von drei einfachen oder drei doppelten Anführungszeichen, die eine mehrzeilige Zeichenfolge darstellen können

"abc" 
或者
'abc'
或者
''' Python
语言 '''

Hinweis: Drei einfache oder drei doppelte Anführungszeichen sind ebenfalls Kommentare. Ein Kommentar in Python ist im Wesentlichen eine Zeichenfolge

• Index:
  Gibt ein einzelnes Zeichen in der Zeichenfolge <string> [M] "abc" [0] oder TempStr [-1] zurück.
• Slicing: Gibt einen Zeichensubstring in der Zeichenfolge <string> [M: N]
  "abc" [1: 3] oder TempStr [0: -1] zurück.

Erweiterte Verwendung des String-Slicing: Verwenden Sie [M: N: K], um Strings entsprechend der Schrittgröße zu schneiden

• <String> [M: N], M fehlt bedeutet zu Beginn , N fehlt bedeutet zu Ende
  "〇 一二 三四五 六 七八 [" [: 3] Das Ergebnis ist "〇 一二"
• <String> [M: N: K] , nach dem Schritt K slice Zeichenfolge
  "12345678 neunzig square" [1: 8: 2] Das Ergebnis ist "Januar - 3rd 57"
  „square Eins zwei drei vier fünf sechs sieben acht achtzig "[:: - 1] das Ergebnis ist " neunzehn acht sieben sechs fünf vier drei zwei eins 〇 "

Sonderzeichen: Escapezeichen \

• Expression spezifische Absicht Escape - Zeichen
  „Es gibt ein doppeltes Anführungszeichen (\“) „ führt hier ist ein doppeltes Anführungszeichen (“)
• Die Escape-Zeichen bilden einige Kombinationen, die einige nicht druckbare Bedeutungen
  "\ b" zurück zum Zeilenvorschub
  "\ n" ausdrücken (der Cursor bewegt sich zum Zeilenanfang)
  "\ r" Wagenrücklauf (der Cursor bewegt sich zum Zeilenanfang)

3.2 String-Operatoren

Betreiber und Verwendung	Beschreibung
x + y	Verketten Sie zwei Zeichenfolgen x und y
n * x oder x * n	Zeichenfolge n mal x kopieren
x in s	Wenn x eine Teilzeichenfolge von s ist, geben Sie True zurück, andernfalls False

example：获取星期字符串

weekStr = "星期一星期二星期三星期四星期五星期六星期日"
weekid = eval(input("请输入星期数字(1-7)："))
pos = (weekid-1) * 3
print(weekStr[pos : pos + 3])

或者

weekStr = "一二三四五六日"
weekid = eval(input("请输入星期数字(1-7)："))
print("星期" + weekStr[weekid-1])

3.3 字符串处理函数

操作符及使用	描述
len(x)	长度，返回字符串 x 的长度 len(“一二三456”) 结果为 6
str(x)	任意类型 x 所对应的字符串形式 str(1.23) 结果为 “1.23”，str([1,2]) 结果为 “[1,2]”
hex(x) 或 oct(x)	整数 x 的十六进制或八进制小写形式字符串 hex(425) 结果为 “0x1a9” oct(425) 结果为 “0o651”
chr(u)	x 为 Unicode 编码，返回其对应的字符
ord(x)	x 为字符，返回其对应的 Unicode 编码

3.4 字符串处理函数

字符串处理函数	描述
str.lower() 或 str.upper()	返回字符串的副本，全部字符小写/大写 "AbCdEfGh".lower() 结果为 “abcdefgh”
str.split(sep=None)	返回一个列表，由 str 根据 sep 被分隔的部分组成 "A,B,C".split(",") 结果为 [‘A’,‘B’,‘C’]
str.count(sub)	返回子串 sub 在 str 中出现的次数 "an apple a day".count(“a”) 结果为 4
str.replace(old, new)	返回字符串 str 副本，所有 old 子串被替换为 new "python".replace(“n”,“n123.io”) 结果为 “python123.io”
str.center(width[,fillchar])	字符串 str 根据宽度 width 居中，fillchar 可选 "python".center(20,"=") 结果为 ‘=======\python=======’
str.strip(chars)	从 str 中去掉在其左侧和右侧 chars 中列出的字符 "= python= “.strip(” =np") 结果为 “ytho”
str.join(iter)	在 iter 变量除最后元素外每个元素后增加一个 str ",".join(“12345”) 结果为"1,2,3,4,5" #主要用于字符串分隔等

3.5 字符串类型的格式化

格式化是对字符串进行格式表达的方式，字符串格式化使用 .format()方法，用法如下：

• <模板字符串>.format(<逗号分隔的参数>)

槽内部对格式化的配置方式
{ <参数序号> ： <格式控制标记>}

:	<填充>	<对齐>	<宽度>	<,>	<.精度>	<类型>
引导符号	用于填充的单个字符	< 左对齐 > 右对齐 ^ 居中对齐	槽设定的输出宽度	数字的千分隔符	浮点数小数精度或 字符串最大输出长度	整数类型 b, c, d, o, x, X 浮点数类型 e, E, f, %

4 time 库的使用

time 库是 Python 中处理时间的标准库，包括三类函数

• 时间获取：time()，ctime()，gmtime()
• 时间格式化：strftime()，strptime()
• 程序计时：sleep()，perf_counter()

import time
time.()

4.1 时间获取

4.2 时间格式化

将时间以合理的方式展示出来，类似字符串格式化，需要有展示模板，展示模板由特定的格式化控制符组成

函数	描述
strftime(tpl, ts)	tpl是格式化模板字符串，用来定义输出效果 ts是计算机内部时间类型变量 >>>t = time.gmtime() >>>time.strftime("%Y-%m-%d %H:%M:%S",t) ‘2018-01-26 12:55:20’

格式化字符串	日期/时间说明	值范围和实例
%Y	年份	0000~9999，例如：1900
%m	月份	01~12，例如：10
%B	月份名称	January~December，例如：April
%b	月份名称缩写	Jan~Dec，例如：Apr
%d	日期	01~31，例如：25
%A	星期	Monday~Sunday，例如：Wednesday
%a	星期缩写	Mon~Sun，例如：Wed
%H	小时（24h制）	00~23，例如：12
%I	小时（12h制）	01~12，例如：7
%p	上/下午	AM, PM，例如：PM
%M	分钟	00~59，例如：26
%S	秒	00~59，例如：26

函数	描述
strptime(str, tpl)	str是字符串形式的时间值 tpl是格式化模板字符串，用来定义输入效果 >>>timeStr = ‘2018-01-26 12:55:20’ >>>time.strptime(timeStr, “%Y-%m-%d %H:%M:%S”) time.struct_time(tm_year=2018, tm_mon=1, tm_mday=26, tm_hour=4, tm_min=11, tm_sec=16, tm_wday=4, tm_yday=26, tm_isdst=0)

4.3 程序计时

函数	描述
perf_counter()	返回一个CPU级别的精确时间计数值，单位为秒 由于这个计数值起点不确定，连续调用差值才有意义 >>>start = time.perf_counter() 318.66599499718114 >>>end - start 22.724523540384666
sleep(s)	s拟休眠的时间，单位是秒，可以是浮点数 >>>def wait(): time.sleep(3.3) >>>wait() #程序将等待3.3秒后再退出

5 实例: 文本进度条

需求分析：采用字符串方式打印可以动态变化的文本进度条，进度条需要能在一行中逐渐变化

Um eine Zeile schrittweise zu ändern, ist eine dynamische Aktualisierung erforderlich. Zeilenumbrüche sind nicht zulässig. Die nach dem Überschreiben der vorherigen Zeichen gedruckten Zeichen. Nach dem Drucken kehrt der Cursor zur vorherigen Position zurück. Hier wird \ r verwendet.

import time
scale = 50
print("执行开始".center(scale//2, "-"))
start = time.perf_counter()
for i in range(scale+1):
    a = '*' * i
    b = '.' * (scale - i)
    c = (i / scale) * 100
    dur = time.perf_counter() - start
    #print() 语句打印完一行自动换行，end=''可以不换行
    print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c, a, b, dur), end = '')
    time.sleep(0.1)
print("\n" + "执行结束".center(scale//2, '-'))

Betriebsergebnis:

6 Zusammenfassung

1. Nummerntyp und Bedienung

• Unendliche Auswahl an Ganzzahltypen und 4 hexadezimalen Darstellungen
• Ungefähr unendlicher Bereich von Gleitkommatypen, Little-Endian und wissenschaftlicher Notation
• +, -, *, /, //,%, **, binärer erweiterter Zuweisungsoperator
• abs () 、 divmod () 、 pow () 、 round () 、 max () 、 min ()
• int () 、 float () 、 complex ()

2. Zeichenfolgentypen und Operationen

• Vorwärts ansteigende Sequenznummer, rückwärts abnehmende Sequenznummer, <string> [M: N: K]
• + 、 * 、 In 、 len () 、 str () 、 hex () 、 oct () 、 ord () 、 chr ()
• .lower () 、. Upper () 、. split () 、. count () 、. replace ()
• Format .center (), .strip (), .join (), .format ()