ディープラーニング Chapter02: Python の基本文法の復習

開発 2023-05-17 05:03:37 訪問数: null

ディープラーニング Chapter02: Python の基本文法の復習

1年以上Pythonに触れていなかったので、今後の深層学習の基礎を築くためにPythonの基礎文法を補います。概要は以下の通りですので、皆様のご参考になれば幸いです。

ここに画像の説明を挿入

記事ディレクトリ

Python基礎学習ルートフローチャート

ここに画像の説明を挿入

Python 入門

環境構築

PyCharm は、ユーザーが Python 言語で開発する際の効率を向上させるのに役立つ一連のツールを備えた Python 統合開発環境です。

Anaconda（公式サイト）は、パッケージの取得や管理が簡単に行え、環境を一元管理できる配布版です。Anaconda には、conda、Python、およびそれらの依存関係を含む 180 以上の科学パッケージが含まれています。

ノート

注釈は次の 2 つのカテゴリに分類されます。一行コメントと複数行のコメント。

  • 一行コメント

コメントできるのは 1 行のみです。構文は次のとおりです。

# 注释内容
  • 複数行のコメント

コンテンツの複数行をコメント化できます。通常、コードの一部をコメント化する場合に使用されます。構文は次のとおりです。

"""
	第一行注释
	第二行注释
	第三行注释
"""

'''
	注释1
	注释2
	注释3
'''

ホットキー:Ctrl + /

変数

変数を定義する

变量名 = 值

変数名のカスタマイズに対応識別子命名規則。

識別子の命名規則は、Python でさまざまな名前を定義する際の統一仕様であり、次のようになります。

  • 数字、文字、アンダースコアで構成されます
  • 数字で始めることはできません
  • 組み込みキーワードは使用できません
  • 大文字と小文字を厳密に区別する
False     None    True   and      as       assert   break     class  
continue  def     del    elif     else     except   finally   for
from      global  if     import   in       is       lambda    nonlocal  not       or      pass   raise    return   try      while     with   yield

my_name = '北山啦'
print(my_name)

北山啦

入出力

入力

Pythonでは、ユーザーが入力したデータを受け取るプログラムの機能がinputになります。

文法：

input("提示信息")
  • プログラムが実行されるとinput、ユーザーの入力を待機し、入力が完了した後も実行を続けます。
  • Python では、inputユーザー入力を受け取った後、それは通常、使いやすいように変数に保存されます。
  • Python では、input受信したユーザー入力データはすべて文字列として扱われます。
address = input('请输入您的CSDN博客地址：')

请输入您的CSDN博客地址：https://beishan.blog.csdn.net/

print(f'您输入的密码是{
      
      address}')
# <class 'str'>
print(type(address))

您输入的密码是https://beishan.blog.csdn.net/
<class 'str'>

出力

  • フォーマットされた出力
    • 記号の書式設定
    • Fストリング
  • 印刷の終わり
print('hello Python')

age = 18
print(age)

# 需求：输出“今年我的年龄是18岁”

age = 20
name = '北山啦'
student_id = '01830115'

print('我的名字是%s' % name, end='\n')
print('我的学号是%s' % student_id)
print(f'我的名字是{
      
      name},今年{
      
      age+1}岁了')

我的名字是北山啦
我的学号是01830115
我的名字是北山啦,今年21岁了
  • %06dは、出力する整数の表示桁数を示します。0で補完できない場合は、現在の桁数を超える場合はそのまま出力されます。
  • %.2f、小数点以下に表示される小数点以下の桁数を示します。
weight = 74.22
print(f"{
      
      weight}")
print("{:.3f}".format(weight))

74.22
74.220

stu_id = 1
print("{:03d}".format(stu_id))

001

いわゆる定型出力とは、コンテンツを一定の形式に従って出力することです。

記号の書式設定

記号の書式設定 変換
%s 弦
%d 符号付き 10 進整数
%f 浮動小数点数
%c キャラクター
%u 符号なし 10 進整数
%o 8 進整数
％バツ 16 進整数 (小文字の ox)
％バツ 16 進整数 (大文字の OX)
%e 科学表記法 (小文字の「e」)
%E 科学表記法 (大文字の「E」)
%g %f および %e の省略形
%G %f および %E の省略形
  • 記号の書式設定
    • %s: フォーマットされた出力文字列
    • %d: フォーマットされた出力整数
    • %f: 出力浮動小数点数の形式
  • Fストリング
    • f'{式}'
  • エスケープ文字
    • \n: 改行
    • \t: タブ文字、タブ キーの例
  • ターミネータの終わりを印刷する

データの種類

ここに画像の説明を挿入

type() 関数を使用してデータ型を表示できます。

num1 = 1
num2 = 1.1
print(type(num1))
print(type(num2))
print(type('北山啦'))
print(type(True))

<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>

データ型を変換する

データ型を変換する関数

関数 説明する
int(x [,base ]) xを整数に変換する
float(x) x を浮動小数点数に変換する
complex(実数 [,imag ]) real を実数部、imag を虚数部として複素数を作成します
str(x) オブジェクト x を文字列に変換します
repr(x ) オブジェクト x を式文字列に変換します
eval(str) 文字列内の有効な Python 式を評価し、オブジェクトを返します。
タプル シーケンス s をタプルに変換します
リスト シーケンス s をリストに変換する
chr(x) 整数を Unicode 文字に変換します
ord(x ) 文字を ASCII 整数値に変換します
16 進数(x) 整数を 16 進数の文字列に変換します
オクト(x) 整数を 8 進数の文字列に変換します
ビン(x) 整数をバイナリ文字列に変換する

いくつかの例

要件: input はユーザー入力を受け取り、ユーザーは「1」を入力し、このデータ 1 を整数に変換します。

num = input('请输入您的幸运数字：')
print(f"您的幸运数字是{
      
      num}")
print(type(num))
print(type(int(num)))

# 1. float() -- 转换成浮点型
num1 = 1
print(float(num1))
print(type(float(num1)))

# 2. str() -- 转换成字符串类型
num2 = 10
print(type(str(num2)))

# 3. tuple() -- 将一个序列转换成元组
list1 = [10, 20, 30]
print(tuple(list1))
print(type(tuple(list1)))


# 4. list() -- 将一个序列转换成列表
t1 = (100, 200, 300)
print(list(t1))
print(type(list(t1)))

# 5. eval() -- 将字符串中的数据转换成Python表达式原本类型
str1 = '10'
str2 = '[1, 2, 3]'
str3 = '(1000, 2000, 3000)'
print(type(eval(str1)))
print(type(eval(str2)))
print(type(eval(str3)))

请输入您的幸运数字：20
您的幸运数字是20
<class 'str'>
<class 'int'>
1.0
<class 'float'>
<class 'str'>
(10, 20, 30)
<class 'tuple'>
[100, 200, 300]
<class 'list'>
<class 'int'>
<class 'list'>
<class 'tuple'>

オペレーター

  • 算術演算子
  • 代入演算子
  • 代入演算子に準拠します
  • 比較演算子
  • 論理演算子

算術演算子

ここに画像の説明を挿入

  • 算術演算の優先順位
    • 混合操作の優先順位:より()高いより高い*** / // %+ -
  • 代入演算子
    • =
  • 複合代入演算子
    • +=
    • -=
    • 優先順位
      1. 複合代入演算子の右側の式が最初に評価されます。
      2. 複合代入演算の算術演算
      3. 最終代入操作
  • 比較演算子
    • 等しいかどうかの判断: ==
    • 以上: >=
    • 以下: <=
    • 等しくない: !=
  • 論理演算子
    • そして、そして、両方とも真実です
    • または: または、一方が true の場合は true、両方が false の場合は false
    • そうでない：そうではない、否定する

ここに画像の説明を挿入

プロセス制御

条件文

Python には 3 種類の条件判断があります。

  • if ステートメントの構文
if 条件:
    条件成立执行的代码
  • もし…そうでなければ…
if 条件:
    条件成立执行的代码
else:
    条件不成立执行的代码
  • 複数の判定
if 条件1:
    条件1成立执行的代码
elif 条件2:
    条件2成立执行的代码
else:
    以上条件都不成立执行的代码

age = int(input('请输入他的年龄：\n'))
if age < 18:
    print(f"你输入的年龄是{
      
      age},童工")
elif 18 <= age <= 60:
    print("你输入的年龄是{},合法".format(age))
elif age > 60:
    print("你输入的年龄是%d,退休" % age)

请输入他的年龄：
20
你输入的年龄是20,合法

猜拳小游戏if 条件文を理解するために直接使用してみましょう。

"""
提示：0-石头，1-剪刀，2-布
1. 出拳
玩家输入出拳
电脑随机出拳,使用random库随机生成0，1，2
"""
import random
computer = random.randint(0, 2)
# print(computer)
player = int(input('请出拳：0-石头，1-剪刀，2-布：'))

if (player == 0 and computer == 1) or (player == 1 and computer == 2) or (player == 2 and computer == 0):
    print('玩家获胜')
elif player == computer:
    print('平局')
else:
    print('电脑获胜')

请出拳：0-石头，1-剪刀，2-布：2
电脑获胜

サイクル

この章では、Python のループ ステートメントについて説明します。プログラムは通常、順番に実行されます。

プログラミング言語は、より複雑な実行パスを可能にするさまざまな制御構造を提供します。

ループ ステートメントを使用すると、ステートメントまたはステートメントのグループを複数回実行できます。ほとんどのプログラミング言語におけるループ ステートメントの一般的な形式は次のとおりです。

ここに画像の説明を挿入

while ループ

while 条件:

条件成立执行代码

具体例:

# 输出5遍博客名
t = 0
while(t < 5):
    print("北山啦")
    t += 1

北山啦
北山啦
北山啦
北山啦
北山啦

# 1-100累加
i = 1
sum = 0
while i <= 100:
    sum += i
    i += 1
print(sum)

5050

1から100までの偶数の累積和

i = 1
sum = 0
while i <= 100:
    if i % 2 == 0:
        sum += i
    i += 1
print(sum)

2550

i = 0
sum = 0
while i <= 100:
    sum += i
    i += 2
print(sum)

2550

休憩と継続

Break と continue は、ループ内で特定の条件が満たされた場合にループを終了する 2 つの異なる方法です。

  • Break はループ フローを制御します。つまり、ループを終了します。

  • continue はループ フローを制御します。つまり、現在のループを終了し、次のループ コードを実行します。

具体例としては以下のようなものが挙げられます

# 循环吃5个苹果，吃完了第3个吃饱了，第4和第5个不吃了
i = 1
while i <= 5:
    if i == 4:
        break
    print(f"吃了第{
      
      i}个苹果")
    i += 1

吃了第1个苹果
吃了第2个苹果
吃了第3个苹果

i = 1
while i <= 5:
    if i == 3:
        print("吃出了一个大虫子，这个苹果不吃了")
        # 如果使用continue，在continue之前一定要修改计数器，否则进入死循环
        i += 1
        continue
    print(f"吃了第{
      
      i}个苹果")
    i += 1

吃了第1个苹果
吃了第2个苹果
吃出了一个大虫子，这个苹果不吃了
吃了第4个苹果
吃了第5个苹果

ネスティング中とその応用

ネスト中の単純なアプリケーション

j = 0
while j < 3:
    i = 0
    while i < 3:
        print("CSDN")
        i += 1
    j += 1
    print("北山啦")

CSDN
CSDN
CSDN
北山啦
CSDN
CSDN
CSDN
北山啦
CSDN
CSDN
CSDN
北山啦

1 行に 5 つのアスタリスクを出力し、5 行を繰り返し印刷します

j = 0
while j < 5:
    i = 0
    while i < 5:
        print("*", end='')
        i += 1
    print()
    j += 1

*****
*****
*****
*****
*****

三角形を印刷する

j = 0
while j < 5:
    i = 0
    while i <= j:
        print("*", end='')
        i += 1
    print()
    j += 1

*
**
***
****
*****

九九九九

# 九九乘法表
for i in range(1, 10):
    for j in range(1, i+1):
        print(f'{
      
      j}*{
      
      i}={
      
      i*j}\t', end='')
    print()

1x1=1	
1x2=2	2x2=4	
1x3=3	2x3=6	3x3=9	
1x4=4	2x4=8	3x4=12	4x4=16	
1x5=5	2x5=10	3x5=15	4x5=20	5x5=25	
1x6=6	2x6=12	3x6=18	4x6=24	5x6=30	6x6=36	
1x7=7	2x7=14	3x7=21	4x7=28	5x7=35	6x7=42	7x7=49	
1x8=8	2x8=16	3x8=24	4x8=32	5x8=40	6x8=48	7x8=56	8x8=64	
1x9=9	2x9=18	3x9=27	4x9=36	5x9=45	6x9=54	7x9=63	8x9=72	9x9=81	

# 九九乘法表
i = 1
while i <= 9:
    j = 1
    while(j <= i):
        print('{}*{}= {}'.format(j, i, i*j), end='\t')
        j += 1
    print('')
    i += 1

1*1= 1	
1*2= 2	2*2= 4	
1*3= 3	2*3= 6	3*3= 9	
1*4= 4	2*4= 8	3*4= 12	4*4= 16	
1*5= 5	2*5= 10	3*5= 15	4*5= 20	5*5= 25	
1*6= 6	2*6= 12	3*6= 18	4*6= 24	5*6= 30	6*6= 36	
1*7= 7	2*7= 14	3*7= 21	4*7= 28	5*7= 35	6*7= 42	7*7= 49	
1*8= 8	2*8= 16	3*8= 24	4*8= 32	5*8= 40	6*8= 48	7*8= 56	8*8= 64	
1*9= 9	2*9= 18	3*9= 27	4*9= 36	5*9= 45	6*9= 54	7*9= 63	8*9= 72	9*9= 81

リスト内包表記の使用

print('\n'.join(
    ['\t'.join([f"{
      
      j}*{
      
      i}={
      
      i*j}" for j in range(1, i + 1)]) for i in range(1, 10)]))

1*1=1
1*2=2	2*2=4
1*3=3	2*3=6	3*3=9
1*4=4	2*4=8	3*4=12	4*4=16
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81

for ループ
構文:

シーケンス内の一時変数の場合:

重复执行的代码1

重复执行的代码2

......

str1 = 'CSDN北山啦'
for i in str1:
    print(i)

C
S
D
N
北
山
啦

休憩して続行します...それ以外の場合

# break
str2 = 'https://beishan.blog.csdn.net/'
for i in str2:
    if i == ':':
        break
    print(i)
else:
    print("循环正常结束执行的else代码")

h
t
t
p
s

# continue
str2 = 'https://beishan.blog.csdn.net/'
for i in str2:
    if i == ':':
        continue
    print(i)
else:
    print("循环正常结束执行的else代码")

h
t
t
p
s
/
/
b
e
i
s
h
a
n
.
b
l
o
g
.
c
s
d
n
.
n
e
t
/
循环正常结束执行的else代码

データシーケンス

type()関数を使用してデータ型を確認できます

ここに画像の説明を挿入

弦

文字列は Python で最も一般的なデータ型であり、文字列の作成には通常引用符を使用します。

一重引用符または三重引用符を使用できます

a = 'https://beishan.blog.csdn.net/'
print(type(a))
b = """原创:CSDN北山啦"""
print(type(b))
c = "I'm 北山啦"
print(c)
print(type(c))

<class 'str'>
<class 'str'>
I'm 北山啦
<class 'str'>

Python では、 を使用してinput()ユーザー入力を受け取ります。Python では、 を使用してprint()ユーザー入力を受け取ります。

スライス

スライスとは、操作対象のオブジェクトの一部を切り取る操作を指します。文字列、リスト、タプルはすべてスライス操作をサポートしています。

文法

序列[开始位置下标:结束位置下标:步长]

知らせ

1. 不包含结束位置下标对应的数据， 正负整数均可；
2. 步长是选取间隔，正负整数均可，默认步长为1。

name = "abcdefg"

print(name[2:5:1])  # cde
print(name[2:5])  # cde
print(name[:5])  # abcde
print(name[1:])  # bcdefg
print(name[:])  # abcdefg
print(name[::2])  # aceg
print(name[:-1])  # abcdef, 负1表示倒数第一个数据
print(name[-4:-1])  # def
print(name[::-1])  # gfedcba

cde
cde
abcde
bcdefg
abcdefg
aceg
abcdef
def
gfedcba

文字列の共通操作

文字列の一般的な操作方法は、検索、変更、判定です。

查找:find()、index()、count()

find(): この文字列に特定の部分文字列が含まれているかどうかを確認し、部分文字列の先頭の添え字を返します。そうでない場合は -1 を返します。

Index(): 特定の部分文字列がこの文字列に含まれているかどうかを確認し、部分文字列の先頭の添え字が返される場合は、例外が報告されます。

count(): 文字列内で部分文字列が出現する回数を返します。

ここに画像の説明を挿入

修改:replace()、split()、join()

  • split(): 指定された文字に従って文字列を分割します。
字符串序列.split(分割字符, num)

注: num は分割文字の発生数を表します。つまり、将来返されるデータの数は num+1 です。

  • join(): 文字列を 1 つの文字または部分文字列とマージします。つまり、複数の文字列を新しい文字列に結合します。
字符或子串.join(多字符串组成的序列)

ここに画像の説明を挿入

Capitalize(): 文字列の最初の文字を大文字に変換します。

title(): 文字列内の各単語の最初の文字を大文字に変換します。

lower(): 文字列の大文字を小文字に変換します。

upper(): 文字列の小文字を大文字に変換します。

ストリップ(): 文字列の両側の空白文字を削除します。lstrip()、rstrip()

center(): 元の文字列を中央に配置し、指定された文字 (デフォルトのスペース) を対応する長さまで埋め込んだ新しい文字列を返します。構文は ljust() と同じです。

判断:startswith()、endwith()、isalpha()、isdigital()

このような関数はたくさんあります。使用する必要がある場合は、Baidu を自分で使用できます。join() や Split() などの最も一般的な関数に慣れることができます。

リスト

リストは最も一般的に使用される Python データ型で、角かっこで囲まれたカンマ区切りの値として表示されます。

リストのデータ項目は同じ型である必要はありません

name_list = ['欢迎', '关注', '北山啦']
print(name_list[0])
print(name_list[1])
print(name_list[2])

欢迎
关注
北山啦

共通機能

インデックス()、カウント()、レン()

name_list = ['欢迎', '关注', '北山啦']
print(name_list.index('北山啦'))
print(name_list.count('北山啦'))c
print(len(name_list))

2
1
3

あるかどうか判断する

in: 指定されたデータがリストシーケンス内にあると判断し、Trueを返した場合、それ以外の場合はFalseを返します。

not in: 指定されたデータがリスト列に含まれないと判断し、そうでない場合は True を返し、そうでない場合は False を返します。

name_list = ['欢迎', '关注', '北山啦']
print('欢迎' in name_list)
print('Lilys' in name_list)

True
False

print('北山' not in name_list)
print('Lilys' not in name_list)

True
True

共通の操作方法

  • 索引（）
  • レン()
  • 追加()
  • 拡張する（）
  • 入れる（）
  • ()の
  • ポップ（）
  • クリア（）
  • 削除（）

同時に、リストには reverse() や sort() などの関数もあります。

import random
teachers = ['zhangzk', 'dfbdaf', 'dfad', 'dfa', 'etw', 'dfa', 'dgdag']
offices = [[], [], []]
for name in teachers:
    num = random.randint(0, 2)
    offices[num].append(name)
print(offices)

[['dfbdaf', 'dfa'], ['zhangzk', 'dfa', 'dgdag'], ['dfad', 'etw']]

[i for j in offices for i in j]

['dfbdaf', 'dfa', 'zhangzk', 'dfa', 'dgdag', 'dfad', 'etw']

for name in offices:
    for i in name:
        print(i, end=' ')

etw dgdag dfad dfa zhangzk dfbdaf dfa

タプル

タプルには複数のデータを保存できますが、タプル内のデータは変更できません

タプルの特性: を使用してタプルを定義します括弧、とコンマ各データは分離されており、データは異なるデータ型である可能性があります。

t1 = (10, 20, 30)
t2 = (10,)
print(type(t1))
print(type(t2))

<class 'tuple'>
<class 'tuple'>

定義されたタプルにデータが 1 つだけある場合は、データの後にコンマを追加することをお勧めします。そうでない場合は、そのデータ型がこのデータの唯一のデータ型になります。

t2 = (10,)
print(type(t2))  # tuple

t3 = (20)
print(type(t3))  # int

t4 = ('hello')
print(type(t4))  # str

<class 'tuple'>
<class 'int'>
<class 'str'>

一般的なメソッドは list に似ています:index()、len()、count()

辞書

辞書の機能:

  • 中括弧としての記号
  • データはキーと値のペアの形式で提供されます
  • キーと値のペアはカンマで区切ります

辞書を作成する

dict1 = {
    
    'name': 'Tom', 'age': 20, 'gender': '男'}  # 有数据的字典
dict2 = {
    
    }  # 创建空字典
dict3 = dict()  # 创建空字典
print(type(dict1))

<class 'dict'>

辞書に対する一般的な操作

  • 増加

キーが存在する場合は、キーに対応する値を変更します。キーが存在しない場合は、このキーと値のペアを追加します。

dict1 = {
    
    'name': '北山啦', 'age': 20, 'gender': '男'}
dict1['name'] = 'Rose'
print(dict1)

{'name': 'Rose', 'age': 20, 'gender': '男'}

dict1['id'] = 110
print(dict1)

{'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}
  • 消去

デル、クリア

dict1 = {
    
    'name': '北山啦', 'age': 20, 'gender': '男'}
# del(dict1)
del dict1['gender']
print(dict1)

{'name': '北山啦', 'age': 20}

dict1.clear()
print(dict1)  # 清空字典

{}
  • 改訂

書き込み: 辞書シーケンス [キー] = 値

注: キーが存在する場合は、キーに対応する値を変更します。キーが存在しない場合は、このキーと値のペアを追加します。

dict1 = {
    
    'name': '北山啦', 'age': 20, 'gender': '男'}
dict1['age'] = 22
print(dict1)

{'name': '北山啦', 'age': 22, 'gender': '男'}
  • 見上げる

検索されたキーが存在する場合は、対応する値を返し、存在しない場合はエラーを報告します。

dict1 = {
    
    'name': '北山啦', 'age': 20, 'gender': '男'}
print(dict1['name'])
print(dict1['id'])

北山啦



---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

C:\Users\ADMINI~1\AppData\Local\Temp/ipykernel_1196/2064109912.py in <module>
      1 dict1 = {'name':'北山啦','age':20,'gender':'男'}
      2 print(dict1['name'])
----> 3 print(dict1['id'])


KeyError: 'id'

辞書でよく使われる関数

get()

  • 文法
字典序列.get(key, 默认值)

注: 現在検索されているキーが存在しない場合は 2 番目のパラメータ (デフォルト値) を返し、2 番目のパラメータが省略された場合は None を返します。

  • クイックエクスペリエンス
dict1 = {
    
    'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.get('name'))  # Tom
print(dict1.get('id', 110))  # 110
print(dict1.get('id'))  # None

keys()

dict1 = {
    
    'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.keys())  # dict_keys(['name', 'age', 'gender'])

values()

dict1 = {
    
    'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.values())  # dict_values(['Tom', 20, '男'])

items()

dict1 = {
    
    'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.items())  # dict_items([('name', 'Tom'), ('age', 20), ('gender', '男')])

辞書をループする

dict1 = {
    
    'name': '北山啦', 'age': 20, 'gender': '男'}
for key in dict1.keys():
    print(key)

name
age
gender

for value in dict1.values():
    print(value)

北山啦
20
男

dict1 = {
    
    'name': 'Tom', 'age': 20, 'gender': '男'}
for item in dict1.items():
    print(item)

('name', 'Tom')
('age', 20)
('gender', '男')

dict1 = {
    
    'name': 'Tom', 'age': 20, 'gender': '男'}
for key, value in dict1.items():
    print(f'{
      
      key}:{
      
      value}')

name:Tom
age:20
gender:男

集める

{}または を使用してコレクションを作成しますset()が、これは空の辞書を作成するset()ために使用されるため、空のコレクションを作成する場合にのみ使用します。{}

コレクションの特徴:

  1. コレクションでは重複データを削除できます。
  2. コレクション データには順序がないため、添字はサポートされません
s1 = {
    
    10, 20, 30, 40, 50}
print(s1)

s2 = {
    
    10, 30, 20, 10, 30, 40, 30, 50}
print(s2)

s3 = set('abcdefg')
print(s3)

s4 = set()
print(type(s4))  # set

s5 = {
    
    }
print(type(s5))  # dict

{50, 20, 40, 10, 30}
{50, 20, 40, 10, 30}
{'a', 'd', 'b', 'e', 'f', 'g', 'c'}
<class 'set'>
<class 'dict'>

共通操作

  • データを増やす
    • add() #単一のデータを追加します
    • update() #追加序列
  • データを削除する
    • 削除（）
    • 破棄（）
s1 = {
    
    10, 20, 30, 40, 50}
s1.add(100)  # 集合是可变的类型
print(s1)

{50, 20, 100, 40, 10, 30}

s1.update([30, 40, 50, 60, 70])
s1  # 集合可以去掉重复数据

{10, 20, 30, 40, 50, 60, 70}

s1.remove(10)

s1

{20, 30, 40, 50, 60, 70}

s1.discard(10)  # 没有该数据不会报错，remove会报错
s1

{20, 30, 40, 50, 60, 70}

パブリックメソッド

  • オペレーター

    • 入っている/入っていない
    オペレーター 説明 サポートされているコンテナの種類
    + マージ 文字列、リスト、タプル
    * コピー 文字列、リスト、タプル
    の 要素が存在します 文字列、リスト、タプル、辞書
    ありませんで 要素が存在しません 文字列、リスト、タプル、辞書

  • パブリックメソッド

    • レン()
    • ()の
    • 範囲（）
    • 列挙()
関数 説明
レン() コンテナ内の要素の数を数える
または() 消去
最大() コンテナ内の要素の最大値を返します。
分() コンテナ内の要素の最小値を返します。
範囲(開始、終了、ステップ) for ループで使用するために、ステップ サイズ step で開始から終了までの数値を生成します。
列挙() 関数は、走査可能なデータ オブジェクト (リスト、タプル、文字列など) をインデックス シーケンスに結合し、データとデータ添え字を同時にリストするために使用され、通常は for ループで使用されます。

  • データ型変換

    • タプル()
    • リスト（）
    • 設定（）

    対応する関数を使用してデータ型変換を実現します

  • 文法

enumerate(可遍历对象, start=0)

注意：start参数用来设置遍历数据的下标的起始值，默认为0。

list1 = ['a', 'b', 'c', 'd', 'e']
for i in enumerate(list1, 1):
    print(i)

(1, 'a')
(2, 'b')
(3, 'c')
(4, 'd')
(5, 'e')

for index, char in enumerate(list1, start=1):
    print(f'下标是{
      
      index}, 对应的字符是{
      
      char}')

下标是1, 对应的字符是a
下标是2, 对应的字符是b
下标是3, 对应的字符是c
下标是4, 对应的字符是d
下标是5, 对应的字符是e

推导式

  • 列表推导式
  • 字典推导式
  • 集合推导式

列表推导式

# while实现
list1 = []
i = 0
while i < 10:
    list1.append(i)
    i += 1
print(list1)

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# for循环实现
list1 = []
for i in range(10):
    list1.append(i)
print(list1)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

list1 = [i for i in range(10)]
print(list1)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

带if的列表推导式

# 创建0-10的偶数列表
list1 = [i for i in range(0, 11, 2)]
print(list1)

[0, 2, 4, 6, 8, 10]

list1 = [i for i in range(0, 11) if i % 2 == 0]
print(list1)

[0, 2, 4, 6, 8, 10]

多个for循环实现列表推导式

list1 = []
for i in range(1, 3):
    for j in range(3):
        list1.append((i, j))
print(list1)

[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

list1 = [(i, j) for i in range(1, 3) for j in range(3)]
print(list1)

[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

列表推导式解包

a = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
b = [x for b in a for x in b]
print(b)

[1, 2, 3, 1, 2, 3, 1, 2, 3]

字典推导式

快速合并列表为字典或者体取字典中目标数据

dict1 = {
    
    i: i**2 for i in range(1, 5)}
print(dict1)

{1: 1, 2: 4, 3: 9, 4: 16}

合并列表为字典

list1 = ['name', 'age', 'gender']
list2 = ['beishan', 20, 'man']

dict1 = {
    
    list1[i]: list2[i] for i in range(len(list1))}
print(dict1)

{'name': 'beishan', 'age': 20, 'gender': 'man'}

提取字典中目标数据

counts = {
    
    'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}
count1 = {
    
    key: value for key, value in counts.items() if value >= 200}
print(count1)

{'MBP': 268, 'DELL': 201}

集合推导式

list1 = [1, 1, 2]
set1 = {
    
    i**2 for i in list1}
print(set1)

{1, 4}

函数

函数就是将一段具有独立功能的代码块整合到一个整体并命名，在需要的位置调用这个名称即可完成对应的需求。

函数在开发过程中，可以更高效的实现代码重用。

  • 函数的作用：封装代码，高效的代码重用

  • 函数使用步骤

    • 定义函数
    def 函数名():
    代码1
    代码2
    ...
    • 调用函数
    函数名()

  • 函数的参数：函数调用的时候可以传入真实数据，增大函数的使用的灵活性

    • 形参：函数定义时书写的参数(非真实数据)
    • 实参：函数调用时书写的参数(真实数据)

  • 函数的返回值

    • 作用：函数调用后，返回需要的计算结果
    • 写法
    return 表达式

  • 函数的说明文档

    • 作用：保存函数解释说明的信息
    • 写法
    def 函数名():
    """ 函数说明文档 """

  • 函数嵌套调用：一个函数内部嵌套调用另外一个函数

函数定义

定义函数

def 函数名(参数):
    代码1
    代码2
    ......

调用函数

函数名(参数)

注意：

1. 不同的需求，参数可有可无。
2. 在Python中，函数必须==先定义后使用==。

具体例子

使用函数，完成加法

def sum_num(a, b):
    return a + b


# 用result变量保存函数返回值
result = sum_num(1, 2)
print(result)

3

函数说明文档

对于python当中许多内置的函数，可以使用help()来获得函数的具体使用方法

当然大家在平时写函数的过程中，为了便于其他人员的使用，增加可读性，也可以适当写函数说明文档

  • 定义函数的说明文档
def 函数名(参数):
    """ 说明文档的位置 """
    代码
    ......
  • 查看函数的说明文档
help(函数名)

help(print)

Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

使用help(函数名)就可以很容易看到print()当中的参数了

def sum_num(a, b):
    """ 求和函数 """
    return a + b


help(sum_num)

Help on function sum_num in module __main__:

sum_num(a, b)
    求和函数

嵌套使用

同时在python中函数也可以嵌套使用的

def testB():
    print('---- testB start----')
    print('这里是testB函数执行的代码...(省略)...')
    print('---- testB end----')


def testA():
    print('---- testA start----')
    testB()
    print('---- testA end----')


testA()

---- testA start----
---- testB start----
这里是testB函数执行的代码...(省略)...
---- testB end----
---- testA end----

如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次 函数A执行的位置。

变量作用域

变量作用域指的是变量生效的范围，主要分为两类：局部变量和全局变量。

  • 局部变量

所谓局部变量是定义在函数体内部的变量，即只在函数体内部生效。

def testA():
    a = 100

    print(a)


testA()  # 100
print(a)  # 报错：name 'a' is not defined

变量a是定义在testA函数内部的变量，在函数外部访问则立即报错。

局部变量的作用：在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量。

  • 全局变量

所谓全局变量，指的是在函数体内、外都能生效的变量。

思考：如果有一个数据，在函数A和函数B中都要使用，该怎么办？

答：将这个数据存储在一个全局变量里面。

a = 100 # 定义全局变量a


def testA():
    print(a)  # 访问全局变量a，并打印变量a存储的数据


def testB():
    print(a)  # 访问全局变量a，并打印变量a存储的数据


testA()  # 100
testB()  # 100

global 关键字声明a是全局变量

  • 如果局部要对全局变量修改，而不使用global关键字,就会报错
 UnboundLocalError: local variable 'count' referenced before assignment

ここに画像の説明を挿入

a = 100  # 定义全局变量a


def testA():
    print(a)


def testB():
    global a
    a = 200
    print(a)


testA()
testB()

100
200

函数的返回值、参数

返回值

思考：如果一个函数如些两个return (如下所示)，程序如何执行？

def return_num():
    return 1
    return 2


result = return_num()
print(result)  # 1

答：只执行了第一个return，原因是因为return可以退出当前函数，导致return下方的代码不执行。

思考：如果一个函数要有多个返回值，该如何书写代码？

def return_num():
    return 1, 2


result = return_num()
print(result)  # (1, 2)

注意：

  1. return a, b写法，返回多个数据的时候，默认是元组类型。
  2. return后面可以连接列表、元组或字典，以返回多个值。
def return_num():
    return (10, 20)


return_num()

(10, 20)
  • 位置参数

位置参数：调用函数时根据函数定义的参数位置来传递参数。

注意：传递和定义参数的顺序及个数必须一致。

def user_info(name, age, gender):
    print(f'您的名字是{
      
      name}, 年龄是{
      
      age}, 性别是{
      
      gender}')


user_info('北山啦', 20, '男')

您的名字是北山啦, 年龄是20, 性别是男
  • 关键字参数

函数调用，通过“键=值”形式加以指定。可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求。

def user_info(name, age, gender):
    print(f'您的名字是{
      
      name}, 年龄是{
      
      age}, 性别是{
      
      gender}')


user_info('Rose', age=20, gender='女')
user_info('小明', gender='男', age=16)

您的名字是Rose, 年龄是20, 性别是女
您的名字是小明, 年龄是16, 性别是男

注意：函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序。

user_info(gender='男', age=16, '小明')

  File "C:\Users\ADMINI~1\AppData\Local\Temp/ipykernel_13808/292338224.py", line 1
    user_info(gender='男', age=16,'小明')
                                     ^
SyntaxError: positional argument follows keyword argument
  • 缺省参数

缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）。

注意：函数调用时，如果为缺省参数传值则修改默认参数值；否则使用这个默认值。

def user_info(name, age, gender='男'):
    print(f'您的名字是{
      
      name}, 年龄是{
      
      age}, 性别是{
      
      gender}')


user_info('TOM', 20)
user_info('Rose', 18, '女')

您的名字是TOM, 年龄是20, 性别是男
您的名字是Rose, 年龄是18, 性别是女
  • 不定长参数

不定长参数也叫可变参数。用于不确定调用的时候会传递多少个参数(不传参也可以)的场景。此时，可用包裹(packing)位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便。

  1. 包裹位置传递
def user_info(*args):#*必须写，args可以为其他的
    print(args)


# ('TOM',)
user_info('TOM')
# ('TOM', 18)
user_info('TOM', 18)

注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是包裹位置传递。

  1. 包裹关键字传递
def user_info(**kwargs):
    print(kwargs)


# {'name': 'TOM', 'age': 18, 'id': 110}
user_info(name='TOM', age=18, id=110)

综上：无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程。

  • 拆包
  1. 拆包:元组
  2. 拆包:字典
def return_num():
    return 100, 200


num1, num2 = return_num()
print(num1)
print(num2)

100
200

dict1 = {
    
    'name': 'beishanla', 'age': 20}
a, b = dict1
print(a)
print(b)

name
age

for i in dict1.keys():
    print(i)

name
age

lambda表达式

lambda 参数列表 ： 表达式

  • lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用。

  • lambda表达式能接收任何数量的参数但只能返回一个表达式的值。

  • 递归

def sum_number(num):
   if num == 1:
       return 1
   return num + sum_number(num-1)
sum_number(3)

lambda表达式的简单例子

f1 = lambda x,y:x+y
print(f1(1, 2))

3

f2 = lambda a,b:a if a > b else b
f2(1000,5000)

5000

列表数据按字典key的值排序

infos = [
    {
    
    'name': 'beishanla', 'age': 20},
    {
    
    'name': 'zhagnzk', 'age': 21},
    {
    
    'name': 'zhangy', 'age': 22},
]

infos.sort(key=lambda x: x['name'], reverse=True)
print(infos)

[{'name': 'zhangy', 'age': 22}, {'name': 'zhagnzk', 'age': 21}, {'name': 'beishanla', 'age': 20}]

マップ、フィルター、リデュース

map:
map(func, lst)、入力関数変数 func を lst 変数の各要素に適用し、新しいリスト (Python2)/反復子 (Python3) を形成して結果を返します。

square = list(map(lambda x: x**2, range(10)))
print(square)

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

square = [x**2 for x in range(10)]
print(square)

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

filter:filter(func, lst) 関数は、シーケンスをフィルター処理し、条件を満たさない要素を除外し、フィルター オブジェクトを返すために使用されます。リストに変換したい場合は、 list() を使用して変換できます。

result = list(filter(lambda x: x % 2 == 0, range(10)))
result

[0, 2, 4, 6, 8]

reduce:reduce(func, lst)、func には 2 つのパラメータが必要です。各関数の計算の結果は、シーケンスの次の要素とともに累積され続けます。

注:reduce() によって渡されるパラメータ func は 2 つのパラメータを受け取る必要があります。

import functools

list1 = [1, 2, 3, 4, 5]


def func(a, b):
    return a + b


result = functools.reduce(func, list1)

print(result)  # 15

15

ファイル操作

  • ファイル操作手順

    • 開ける
    文件对象 = open(目标文件, 访问模式)
  
 with open(目标文件,访问模式):

    • 操作する

      • 読む
      文件对象.read()
文件对象.readlines()
文件对象.readline()
      • 書く
      文件对象.write()
      • 求める（）

    • 閉鎖

    文件对象.close()

  • マスターアクセスモード

    • w:書き込み、ファイルが存在しない場合は新しいファイルを作成します
    • r: 読み取り、ファイルが存在しない場合、エラーが報告されます。
    • a：追加

  • ファイルとフォルダーの操作

    • 名前の変更: os.rename()
    • 現在のディレクトリを取得します: os.getcwd()
    • ディレクトリリストを取得します: os.listdir()

以上です。役に立った場合は、「いいね！」と「フォロー」をお願いします。あなたの「いいね！」は私にとって非常に重要です。著者：北山

ここに画像の説明を挿入

おすすめ

転載: blog.csdn.net/qq_45176548/article/details/124772363
おすすめ
大規模な言語モデルに基づくオープンソースのナレッジベースの質問と回答システムである MaxKB GitHub Star の数が 5,000 を超えました。
ランキング
短线选股的一种方法
Javaクライアントでのユーバーのリズムワークフローで睡眠時間をキャンセルし、再スケジュール
CALIPSOデータバッチダウンロード方式
LeetCode アルゴリズム再帰クラス - ソードはオファー 26 を参照します。 ツリーの部分構造
HTMLのインポート外部CSS、JavaScriptの論文
PostgreSQL 13.1、12.5、11.10、10.15、9.6.20、および9.5.24がリリースされました
アップルは、エラーメッセージがポテトに接続されていた実行する方法ポテトポテトショーをダウンロードすることができません
あなたは空腹で突然電話を切っていますか？これはテクノロジーの裏側ですか、それともテスト用の銃ですか？
VIMエディタのヒント
動的計画法の最長共通部分列（LCS）
アーカイブ
もっと
2024-05-13(8)
2024-05-12(27)
2024-05-11(31)
2024-05-10(33)
2024-05-09(30)
2024-05-08(18)
2024-05-07(34)
2024-05-06(6)
2024-05-05(0)
2024-05-04(18)

コードワールド

© 2018 codetd.com