Python を始めるための基本を詳細にまとめて共有します。

この記事では、Python に関する関連知識を提供し、主に識別子、変数、条件文など、Python を始めるための基本に関連する関連コンテンツをまとめています。見てください、それが皆さんのお役に立てば幸いです。

【関連する推奨事項: Python3 ビデオ チュートリアル ]

識別子

Python では、すべての識別子に 英語 (大文字と小文字が区別される)、数字、アンダースコア (_) を含めることができますが、「次で始まる」で始めることはできません。数字。

単一のアンダースコアで始まります は _foo を表します は のクラス属性に直接アクセスできません。クラスが提供するインターフェイスを介してアクセスする必要があります。インポートできませんxxx import * から使用します。

二重アンダースコア

で始まる#__fooは、クラスのプライベートメンバーを表します。

二重アンダースコアで始まり、

で終わります。 __foo__ は、クラスのコンストラクターを表す __init__() など、Python の特別なメソッドの特別な識別子を表します。 ステートメント

Python コード ブロックでは、行の先頭に同じ数の number 個のインデントされたスペースを使用する必要があります

Python の場合単一行のコメント# で始めます。

Python での複数行のコメント単一引用符 (''') を 3 つ使用するか、二重引用符 (""") を 3 つ使用します。

# Python语句中一般以新行作为语句的结束符。但是我们可以使用【斜杠（ \）】将一行的语句分为多行显示，
# 语句中包含 [], {} 或 () 括号就不需要使用多行连接符。
# Python可以在同一行中使用多条语句，语句之间使用【分号(;)】分割
total = item_one + \
        item_two + \
        item_three
days = ['Monday', 'Tuesday', 'Wednesday',
        'Thursday', 'Friday']

# Python可以在同一行中使用多条语句，语句之间使用【分号(;)】分割。
import sys; x = 'runoob'; sys.stdout.write(x + '\n')

# Python 可以使用【引号( ' )、双引号( " )、三引号( ''' 或 """ ) 】来表示字符串
word = 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句"""

# print 默认输出是换行的，如果要实现【不换行需要在变量末尾加上逗号】 。
print x,y

変数

Python3 には 6 つの標準データ型があります:

Number (数値)

• String (string )

• List (リスト)

• Tuple (タプル)

• Set (セット)

• Dictionary

• Python3 の 6 つの標準データ型のうち:
  不変データ (3) : Number (数値)、String (文字列)、Tuple (タプル);

変数データ(3):List(リスト)、Dictionary(辞書)、Set(セット).

Number(数字)

int、float、bool、complex (複数形)

内部関数では、文字列、タプル、および数値

は変更不可能なオブジェクトであり、グローバル変数は初期化変数であるか、定義されている必要があります関数内で self を使用します。

list、dict

などは変更可能なオブジェクトであり、内部関数は関数内でローカル変数を直接使用できます。 List(リスト)

counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串

二进制转换：
int('10',2) 
> 2
bin(10)
> '0b1010'
bin(10)[2:]

ord(c) # c为字符
# 返回值：对应的十进制整数（ASCll数值）
int(c) # c为字符，转化为对应的数字

float('-inf') # 最小值
-inf

a = b = c = 1
a, b, c = 1, 2, "john"

all() # 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。

# 从左到右索引默认【0开始的】，最大范围是字符串【长度少1】
# 从右到左索引默认【-1开始的】，最大范围是【字符串开头】
# 第三个参数，参数作用是【截取的步长】
s = "a1a2···an"   # n>=0

向上取整：math.ceil()
向下取整：math.floor()、整除"//"
四舍五入：round()——奇数向远离0取整，偶数去尾取整；或言之：奇数进位，偶数去尾
向0取整：int()

#tuple(タプル)

tinylist = [123, 'john']
print list[0]            # 输出列表的第一个元素
print list[1:3]          # 输出第二个至第三个元素 
print list[2:]           # 输出从第三个开始至列表末尾的所有元素

# 二维数组
num_list = [ [0] * 5 for i in range(2)]
dp = [[1]*n] + [[1]+[0] * (n-1) for _ in range(m-1)]

clone_node.neighbors = [self.cloneGraph(n) for n in node.neighbors] 

# 加号 + 是列表连接运算符，星号 * 是重复操作
print tinylist * 2       # 输出列表两次
print list + tinylist    # 打印组合的列表

list.append('Google')   # 使用 append() 添加元素
del list[2]			# 可以使用 del 语句来删除列表的元素
list.pop(3)			# 指定pop参数，将会删除该位置的元素；无参数时默认删除最后一个元素

list.append(sublist) # 引用传递
list.append([]+sublist) # 值传递
list.append(list(path))

len([1, 2, 3])	3	#长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	#组合
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	#重复
3 in [1, 2, 3]	True	#元素是否存在于列表中
for x in [1, 2, 3]: print x,	1 2 3	#迭代

[::-1] # 数组反转

max(list) # 求list的最大值

sum(sp[i] for i in range(n)) #求和
sum(s in jewelsSet for s in stones)

nums.sort() # 排序
score.sort(reverse=True)
list有一个sort方法，list.sort()将list进行排序，返回None
sort(*,key = None,reverse = False)
key是一个函数，这个函数的作用是从list的每个元素中提取用于当作排序依据的属性
默认是从小到大，即reserve为False的时候，如果reserve为True，排列顺序就是从大到小
def f(item):
    return item[1]
list.sort(key = f)
list.sort(key = lambda item:item[0])

sorted(iterable,*,key=None,reverse=False) # 默认正序排列
sorted(dict.items(),key=lambda item:item[0])
res = sorted(hash,key = lambda word:(-hash[word],word)) # 第一个参数 -hash[word] 即单词出现次数的相反数
# 当词频相同时，用第二个参数 word 进行排序，即字母正序排列

列表解析 List Comprehensions
表达式：[expression for iter_val in iterable if cond_expr]
[expression]：最后执行的结果
[for iter_val in iterable]：这个可以是一个多层循环
[if cond_expr]：两个for间是不能有判断语句的，判断语句只能在最后；顺序不定，默认是左到右。

print[(x,y)for x in [1,2]for y in [3,4]]

for (k1, v1), (k2, v2) in zip(dict_one, dict_two): # 遍历两个list或者dict

for item in product([1,2],[10,20]): # 对矩阵做笛卡尔积
    print(item)
for i, j in product(range(m), range(n)):


neighbors = [(1,0), (1,-1), (0,-1), (-1,-1), (-1,0), (-1,1), (0,1), (1,1)]
for neighbor in neighbors:
	r = (row + neighbor[0])
	c = (col + neighbor[1])
for u,v in neighbors:
	
s = [1, 2, 3, 4, 5]
# 从指定索引1开始
for index, value in enumerate(s, 1):

list(str(n)) # int转化为字符串，转化为list

next(word for word,f in freq.items() if f==maxFreq) # next()取list第一个值

map(max, grid) # 求每行的最大值
map(max, zip(*grid)) # 求每列的最大值
strs = map(str,nums) # 转换为list(str)
r1,m1 = map(int, num1[:-1].split('+')) # list(str)转化为list(int)
list(map(list,numSet))

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 返回一个对象
>>> zipped
<zip object at 0x103abc288>
>>> list(zipped)  # list() 转换为列表
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c))              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> a1, a2 = zip(*zip(a,b))          # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]

#Dict(辞書)

# 元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。
tinytuple = (123, 'john')

# #set(set)

# 字典用"{ }"标识。字典由索引(key)和它对应的值value组成。
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"

# 值可以取任何数据类型，但键必须是不可变的，如字符串，数字或 元组 。 用列表就不行
dict[tuple(count)]

# 以列表返回字典中的所有值
dict.values()
list(dict.values())

for key in dict:
    print (key)

tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}
print dict['one']          # 输出键为'one' 的值
print dict[2]              # 输出键为 2 的值

print tinydict             # 输出完整的字典
print tinydict.keys()      # 输出所有键
print tinydict.values()    # 输出所有值
maxFreq = max(freq.values()) # 求value的最大值

tinydict['Age'] = 8 # 更新
tinydict['School'] = "RUNOOB" # 添加

del tinydict['Name']  # 删除键是'Name'的条目
tinydict.clear()      # 清空字典所有条目
del tinydict          # 删除字典

defaultdict(list)   defaultdict(int) # defaultdict类的初始化函数接受一个类型作为参数，当所访问的键不存在的时候，可以实例化一个值作为默认值：

count.get(c, 0) # 默认值为0

items():返回所有（key，value）元组的数组,类似于‘列表’
[s for s, c in cnt.items() if c == maxCnt] # 遍历dict

dict排序
sorted(dict.items(),key=lambda item:item[0])

items = [(-val, key) for key, val in count.items()] # 变更为tuple
for val, key in sorted(items): # 遍历排序后的tuple

Operator

/ 除算 - x y で除算

#% モジュロ -除算の余りを返します

**

べき乗 - x の y 乗を返します//

整数で割る - 商の整数部分を返します (四捨五入) down)

and
x と y ブール AND - x が False の場合、x と y は False を返し、それ以外の場合は y を返します。 x の計算値。or
x or y Boolean "or" - x がゼロ以外の場合は x の計算値を返し、それ以外の場合は y の計算値を返します。 not
not x Boolean "not" - x が True の場合、False を返します。

is

is は、2 つの識別子がオブジェクトを参照しているかどうかを判断するために使用されます。is not
is not used 2 つの識別子が異なるオブジェクトを参照しているかどうかを判断します。is は == とは異なります。
: is は、2 つの変数によって参照されるオブジェクトが同じ (同じメモリ空間) かどうかを判断するために使用されます。 , == は、参照変数の値が等しいかどうかを判断するために使用されます。

#条件ステートメント

parame = {value01,value02,...}
或者
set(value)

s.add( x )

s.update( x ) # 参数可以是列表，元组，字典等

s.remove( x )

s.discard( x )

len(s)

s.clear()

x in s

for key in set:
    print (key)

ループ ステートメント

if num == 3:            # 判断num的值
    print 'boss'        elif num == 2:
    print 'user'elif num == 1:
    print 'worker'elif num < 0:           # 值小于零时输出
    print &#39;error&#39;else:
    print &#39;roadman&#39;     # 条件均不成立时输出

文字列

i = 1
while i < 10:   
    i += 1
    if i%2 > 0:     # 非双数时跳过输出
        continue
    print i         # 输出双数2、4、6、8、10
    
i = 1
while 1:            # 循环条件为1必定成立
    print i         # 输出1~10
    i += 1
    if i > 10:     # 当i大于10时跳出循环
        break

flag = 1
while (flag): print 'Given flag is really true!'

fruits = ['banana', 'apple',  'mango']
for fruit in fruits:        # 第二个实例
   print ('当前水果: %s'% fruit)

fruits = ['banana', 'apple',  'mango']
for index in range(len(fruits)):
   print ('当前水果 : %s' % fruits[index])

for i in reversed(range(length - 1)): # 逆序

for letter in 'Python':     # 第一个实例
   if letter == 'h':
      break
   print '当前字母 :', letter

for i, ch in enumerate(s):
	if frequency[ch] == 1:
		return i

diff = [(a,b) for a,b in zip(s,goal) if a!=b]

文字列の書式設定

+	字符串连接	
>>>a + b
'HelloPython'

*	重复输出字符串	
>>>a * 2
'HelloHello'

[]	通过索引获取字符串中字符	
>>>a[1]
'e'

[ : ]	截取字符串中的一部分	
>>>a[1:4]
'ell'

in	成员运算符 - 如果字符串中包含给定的字符返回 True	
>>>"H" in a
True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True	
>>>"M" not in a
True

r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。	
>>>print r'\n'
\n
>>> print R'\n'
\n

strs = 'abcd'
for ch in strs:
    print(ch)

strs = 'abcd'
for index in range(len(strs)):
    print(strs[index], end=' ')

res += 'a'*3 # 'aaa'

s.split(" ") # 将字符串分割成单词列表

" ".join(list) # 将单词列表转换为字符串，以空格分隔

f'{bulls}A{cows}B' # {}计算格式化

a = list(str(n)) # int转成list
a[i-1] = str(int(a[i-1]) - 1) # 操作字符
int("".join(a)) # list转化为int

isdigit # 函数判断是否数字
isalpha # 判断是否字母

三重引用符

print "My name is %s and weight is %d kg!" % ('Zara', 21) 
%s	 格式化字符串
%d	 格式化整数
%f	 格式化浮点数字，可指定小数点后的精度

関数

允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符
 >>> hi = '''hi 
there'''
>>> hi   # repr()
'hi\nthere'
>>> print hi  # str()
hi 
there

関数

Pythonでは、

文字列、タプル、数値は変更不可能なオブジェクトですが、list、dict

などは変更可能なオブジェクトです。

不変型: 変数に a=5 を代入した後、a=10 を代入します。ここでは実際に新しい int 値オブジェクト 10 が生成され、そこに a がポイントされ、5 は破棄されます。 aの値を変更しないことは、新たにaを生成することと同等です。 変数の種類: 変数の代入 la=[1,2,3,4] と代入 la[2]=5 により、リスト la の 3 番目の要素の値が変更されます。la 自体は移動されず、その内部の一部のみが移動されます。値が変更されました。

Python では、数値、文字、タプルなどの 不変オブジェクト 型は

値転送

に属しますが、辞書やリストなどは可変オブジェクト型です。 は pass-by-reference に属します。 新しい割り当てを変更し、元のオブジェクトを変更しない場合は、Python のコピー モジュール、つまりオブジェクト コピーを使用する必要があります。

copy.copy は浅いコピーで、第 1 レベルのリストをコピーします。一方、copy.deepcopy は深いコピーで、リストのすべてのサブ要素を深くコピーします。

string.count(str, beg=0, end=len(string))
# 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数

string.endswith(obj, beg=0, end=len(string))
# 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.

string.find(str, beg=0, end=len(string))
# 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1

string.format()
# 格式化字符串

string.index(str, beg=0, end=len(string))
# 跟find()方法一样，只不过如果str不在 string中会报一个异常.

string.join(seq)
# 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

string.replace(str1, str2,  num=string.count(str1))
# 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.

string.split(str="", num=string.count(str))
# 以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+1 个子字符串

匿名関数

#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print "Name: ", name
   print "Age ", age
   return
#调用printinfo函数
printinfo( age=50, name="miki" )
printinfo( name="miki" )


# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print "输出: "
   print arg1
   for var in vartuple:
      print var
   return
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )

import copy
l1 = [[1, 2], 3]
l2 = copy.copy(l1)
l3 = copy.deepcopy(l1)
l2.append(4)
l2[0].append(5)
l3[0].append(6)
l1 = [[1, 2, 5], 3]
l2 = [[1, 2, 5], 3, 4]
l3 = [[1, 2, 6], 3]

モジュール

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数
print "相加后的值为 : ", sum( 10, 20 )
print "相加后的值为 : ", sum( 20, 20 )

検索パス
1. 現在ディレクトリ
2. 現在のディレクトリにない場合、Python はシェル変数 PYTHONPATH の下にあるすべてのディレクトリを検索します。

3. どちらも見つからない場合、Python はデフォルトのパスをチェックします。 UNIX では、通常、デフォルトのパスは /usr/local/lib/python/ です。

モジュール検索パスは、システム モジュールの sys.path 変数に保存されます。変数には、現在のディレクトリ、PYTHONPATH、およびインストール プロセスによって決定されるデフォルトのディレクトリが含まれます。

Python中的包
包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。

简单来说，包就是文件夹，但该文件夹下必须存在 __init__.py 文件, 该文件的内容可以为空。 __init__.py 用于标识当前文件夹是一个包。

考虑一个在 package_runoob 目录下的 runoob1.py、runoob2.py、 __init__.py 文件，test.py 为测试调用包的代码，目录结构如下:
test.py
package_runoob
|-- __init__.py
|-- runoob1.py
|-- runoob2.py

# 导入 Phone 包from package_runoob.runoob1 import runoob1from package_runoob.runoob2 import runoob2
 
runoob1()runoob2()

文件

str = input("请输入：")
print "你输入的内容是: ", str

fo = open("foo.txt", "w")
print "文件名: ", fo.name
print "是否已关闭 : ", fo.closed
print "访问模式 : ", fo.mode
print "末尾是否强制加空格 : ", fo.softspace

# 打开一个文件
fo = open("foo.txt", "w")
str = fo.read(10)
fo.write( "www.runoob.com!\nVery good site!\n")
# 关闭打开的文件
fo.close()

文件和文件夹

import os
os.rename( "test1.txt", "test2.txt" )
os.remove("test2.txt")

os.mkdir("test")
# 将当前目录改为"/home/newdir"
os.chdir("/home/newdir")
# 给出当前的目录
print os.getcwd()
# 删除”/tmp/test”目录
os.rmdir( "/tmp/test"  )

异常

try:
    正常的操作
   ......................
except:
    发生异常，执行这块代码
   ......................
else:
    如果没有异常执行这块代码

try:
    fh = open("testfile", "w")
    fh.write("这是一个测试文件，用于测试异常!!")
except IOError:
    print "Error: 没有找到文件或读取文件失败"
else:
    print "内容写入文件成功"
    fh.close()

try-finally 语句无论是否发生异常都将执行最后的代码。
try:
<语句>
finally:
<语句>    #退出try时总会执行
raise

try:
    fh = open("testfile", "w")
    try:
        fh.write("这是一个测试文件，用于测试异常!!")
    finally:
        print "关闭文件"
        fh.close()
except IOError:
    print "Error: 没有找到文件或读取文件失败"

面向对象

class Employee:
   '所有员工的基类'
   empCount = 0
 
   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount
 
   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary
 
"创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
"创建 Employee 类的第二个对象"
emp2 = Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

empCount 变量是一个类变量，它的值将在这个类的所有实例之间共享。你可以在内部类或外部类使用 Employee.empCount 访问。

第一种方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法

self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。

继承

class A:        # 定义类 A
.....

class B:         # 定义类 B
.....

class C(A, B):   # 继承类 A 和 B
.....

重写

class Parent:        # 定义父类
   def myMethod(self):
      print '调用父类方法'
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print '调用子类方法'

运算符重载

class Parent:        # 定义父类
   def myMethod(self):
      print '调用父类方法'
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print '调用子类方法'

类属性和方法

类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的方法
在类的内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self,且为第一个参数

类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，不能在类的外部调用。在类的内部调用 self.__private_methods

单下划线、双下划线、头尾双下划线说明：
__foo__: 定义的是特殊方法，一般是系统定义名字 ，类似 __init__() 之类的。

_foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *

__foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

【相关推荐：Python3视频教程 】

以上がPython を始めるための基本を詳細にまとめて共有します。の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。