标识符
在 Python 中,所有标识符可以包括英文(区分大小写的)、数字以及下划线(_),但不能以数字开头。
以单下划线开头 _foo 的代表不能直接访问的类属性,需通过类提供的接口进行访问,不能用 from xxx import * 而导入。
以双下划线开头的 __foo 代表类的私有成员,
以双下划线开头和结尾的 __ foo__ 代表 Python 里特殊方法专用的标识,如 __init__() 代表类的构造函数。
语句
Python 的代码块中必须使用相同数目的行首缩进空格数
python中单行注释采用 # 开头。
python 中多行注释使用三个单引号(‘’')或三个双引号(“”")。
# 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 中有六个标准的数据类型:
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) # 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()
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') # 使用 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]
tuple(元组)
# 元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值,相当于只读列表。 tinytuple = (123, 'john')
Dict(字典)
# 字典用"{ }"标识。字典由索引(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
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: # 判断num的值 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 # 输出双数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
函数
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 个子字符串
函数
在 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函数 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 )
模块
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
# 导入 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中文网其它相关文章!
前端(VUE)零基础到就业课程:点击学习
快捷开发Web应用及小程序:点击使用
![](http://m.sbmmt.com/img/upload/article/000/000/020/633501a29d313483.png)