【Python】全网最详细的Python入门基础教程(非常详细,整理而来)

在 Python 中,所有标识符可以包括 英文(区分大小写的)、数字以及下划线(_),但不能以数字开头。

单下划线开头 _foo 的代表 不能直接访问的类属性,需通过类提供的接口进行访问,不能用 from xxx import * 而导入。
双下划线开头的 foo 代表类的 私有成员
双下划线开头和结尾
foo__ 代表 Python 里 特殊方法专用的标识,如 init() 代表类的构造函数。

Python 的代码块中必须使用相同数目的 行首缩进空格数

python单行注释采用 # 开头。
python 中 多行注释使用三个单引号(”’)或三个双引号(“””)。


total = item_one + \
        item_two + \
        item_three
days = ['Monday', 'Tuesday', 'Wednesday',
        'Thursday', 'Friday']

import sys; x = 'runoob'; sys.stdout.write(x + '\n')

word = 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句"""

print x,y

Python3 中有六个标准的数据类型:
Number(数字)
String(字符串)
List(列表)
Tuple(元组)
Set(集合)
Dictionary(字典)

Python3 的六个标准数据类型中:
不可变数据(3 个):Number(数字)、String(字符串)、Tuple(元组);
可变数据(3 个):List(列表)、Dictionary(字典)、Set(集合)。

Number(数字)

int、float、bool、complex(复数)

内部函数中, strings, tuples, 和 numbers 是不可更改的对象,全局变量必须为init变量或者在函数中用self定义;而 list,dict 等则是可以修改的对象,内部函数可以直接使用函数中的局部变量。

counter = 100
miles = 1000.0
name = "John"

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

ord(c)

int(c)

float('-inf')
-inf

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

all()

s = "a1a2···an"

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

List(列表)

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')
del list[2]
list.pop(3)

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)

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))

列表解析 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):

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]

for index, value in enumerate(s, 1):

list(str(n))

next(word for word,f in freq.items() if f==maxFreq)

map(max, grid)
map(max, zip(*grid))
strs = map(str,nums)
r1,m1 = map(int, num1[:-1].split('+'))
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)
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c))
[(1, 4), (2, 5), (3, 6)]
>>> a1, a2 = zip(*zip(a,b))
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]

tuple(元组)


tinytuple = (123, 'john')

Dict(字典)


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']
print dict[2]

print tinydict
print tinydict.keys()
print tinydict.values()
maxFreq = max(freq.values())

tinydict['Age'] = 8
tinydict['School'] = "RUNOOB"

del tinydict['Name']
tinydict.clear()
del tinydict

defaultdict(list)   defaultdict(int)

count.get(c, 0)

items():返回所有(key,value)元组的数组,类似于'列表'
[s for s, c in cnt.items() if c == maxCnt]

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

items = [(-val, key) for key, val in count.items()]
for val, key in sorted(items):

set(集合)

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)

/ 除 – x除以y
% 取模 – 返回除法的余数
** 幂 – 返回x的y次幂
//** 取整除 – 返回商的整数部分(向下取整)

and x and y 布尔”与” – 如果 x 为 False,x and y 返回 False,否则它返回 y 的计算值。
or x or y 布尔”或” – 如果 x 是非 0,它返回 x 的计算值,否则它返回 y 的计算值。
not not x 布尔”非” – 如果 x 为 True,返回 False 。

is is 是判断两个标识符是不是引用自一个对象
is not is not 是判断两个标识符是不是引用自不同对象
is 与 == 区别
is 用于判断两个变量引用对象是否为同一个(同一块内存空间), == 用于判断引用变量的值是否相等。

if num == 3:
    print 'boss'
elif num == 2:
    print 'user'
elif num == 1:
    print 'worker'
elif num < 0:
    print 'error'
else:
    print 'roadman'
i = 1
while i < 10:
    i += 1
    if i%2 > 0:
        continue
    print i

i = 1
while 1:
    print i
    i += 1
    if 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

s.split(" ")

" ".join(list)

f'{bulls}A{cows}B'

a = list(str(n))
a[i-1] = str(int(a[i-1]) - 1)
int("".join(a))

isdigit
isalpha

字符串格式化

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

三引号

允许一个字符串跨多行,字符串中可以包含换行符、制表符以及其他特殊字符
 >>> hi = '''hi
there'''
>>> hi
'hi\nthere'
>>> print hi
hi
there
string.count(str, beg=0, end=len(string))

string.endswith(obj, beg=0, end=len(string))

string.find(str, beg=0, end=len(string))

string.format()

string.index(str, beg=0, end=len(string))

string.join(seq)

string.replace(str1, str2,  num=string.count(str1))

string.split(str="", num=string.count(str))

在 python 中, strings, tuples, 和 numbers 是不可更改的对象,而 list,dict 等则是可以修改的对象。

不可变类型:变量赋值 a=5 后再赋值 a=10,这里实际是新生成一个 int 值对象 10,再让 a 指向它,而 5 被丢弃,不是改变a的值,相当于新生成了a。
可变类型:变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改,本身la没有动,只是其内部的一部分值被修改了。

在Python中,数字、字符或者元组等 不可变对象类型都属于 值传递,而字典dict或者列表list等 可变对象类型属于 引用传递
如果要想修改新赋值后原对象不变,则需要用到python的copy模块,即对象拷贝。
copy.copy属于浅拷贝,拷贝的是第一层list,而copy.deepcopy属于深拷贝,对list所有子元素都进行深拷贝。


def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print "Name: ", name
   print "Age ", age
   return

printinfo( age=50, name="miki" )
printinfo( name="miki" )

def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print "输出: "
   print arg1
   for var in vartuple:
      print var
   return

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

print "相加后的值为 : ", sum( 10, 20 )
print "相加后的值为 : ", sum( 20, 20 )
import support

from fib import fibonacci

from math import *

搜索路径
1、当前目录
2、如果不在当前目录,Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
3、如果都找不到,Python会察看默认路径。UNIX下,默认路径一般为/usr/local/lib/python/。
模块搜索路径存储在 system 模块的 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


from package_runoob.runoob1 import runoob1
from 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")

os.chdir("/home/newdir")

print os.getcwd()

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:
<语句>
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:
.....

class B:
.....

class C(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: 双下划线的表示的是 私有类型(private)的变量, 只能是允许这个类本身进行访问了。

Original: https://blog.csdn.net/HNUPCJ/article/details/123276665
Author: HNUJSY
Title: 【Python】全网最详细的Python入门基础教程(非常详细,整理而来)

原创文章受到原创版权保护。转载请注明出处:https://www.johngo689.com/726927/

转载文章受原作者版权保护。转载请注明原作者出处!

(0)

大家都在看

亲爱的 Coder【最近整理,可免费获取】👉 最新必读书单  | 👏 面试题下载  | 🌎 免费的AI知识星球