090-pyhon-工作中用到的语法总结

 

 

---

 

【1】表达式  

eg:    2+2   

由 值  与  操作符 组成，并且可以求值。

//可以是字符串和字符串的求值，也可以是数字和数字的表达是求值。

【2】操作符

**  取模

% 取模、取余

// 整除

* 乘法

-减法

+加法（可以从来操作字符串和两个数）

【3】值得类型

（1）浮点型   float

（2）整形

（3）字符串

【4】字符串的操作符

（1）把两个字符串连起来用+ 号             

          'lian'+'qilai'

（2）把字符串复制复制n倍  用*号           

          'chengNbei'*8

【5】变量初始化

（1）在被创建时第一次被存入一个值

（2）只能是一个词、只能包含数字字母下划线、不能以数字开头

【6】print函数

print('hello world!')

【7】input函数

shuru=input()  

【8】+  操作 数字和字符串时候

str(12)+'zifuchuan'

【9】总结：

（1）操作符分为数学操作符    +   -  *      、    、、    %     **

（2）字符串操作符                    +    *  

（3）3种数据类型         整形、浮点型、字符串

【10】布尔值

只有两个值     True    False

【11】比较操作符    //其求值结果为一个布尔值

==            //当然可以用来比较两个字符串，例如：'zifu'=='zifu2'   

！=      

<     

>

<= 

>=

【12】布尔操作符：用于不叫布尔值

（1）

and     同真则真

or      同假则假

not      相反的布尔值

（2）优先级      not    >and >or

【13】控制流语句

if   mingzi=='zlong':

     print("shuaige")

elif age>12:

     print('aiyou')

else:

    printf("wanla")

【14】while

while   age<5:

     print("haha")

      age=age-1

【14】break，退出while。

while   age<5:

     print("haha")

      age=age-1

       if name=="shuaige":

             break

【15】continue，跳回到循环开始的地方

【16】for 循环和range ，执行固定次数

//   0    0.0     ‘’   被认为是False  ，其他为True

for i in range(5)//也可以是for i  in range(2:10)//又或者 for i in range(0,10,2)   其中2是步长

     print("变量i将递增到（但不包括）5")

 

(1)range(start, stop[, step])

• start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
• stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
• step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

【17】导入模块

import random  ,sys,os,math     

例如：两个整数间的一个随机数    random.rand(1,10)

//如果不想加前缀random，可以from random import *

【18】提前结束程序

sys.exit

【19】函数

def   name(参数)

     return "值或者表达式或者None"

（1）def foo(*args,**kwargs):    // 元祖    字典，两类的参数自动给你转换成这两种参数            这段引用的链接放到最后了

*args表示任何多个无名参数，它是一个tuple

**kwargs表示关键字参数，它是一个dict

例如：

def foo(*args,**kwargs):
print 'args=',args
print 'kwargs=',kwargs
print '**********************'
if __name__=='__main__':
foo(1,2,3)
foo(a=1,b=2,c=3)
foo(1,2,3,a=1,b=2,c=3)
foo(1,'b','c',a=1,b='b',c='c')

输出为：

args= (1, 2, 3)
kwargs= {}
**********************
args= ()
kwargs= {'a': 1, 'c': 3, 'b': 2}
**********************
args= (1, 2, 3)
kwargs= {'a': 1, 'c': 3, 'b': 2}
**********************
args= (1, 'b', 'c')
kwargs= {'a': 1, 'c': 'c', 'b': 'b'}

（2）参数检查 

def   hanshumingzi(name: str) -> str:     #指定参数类型和返回类型
    return 'Hello ' + name

（3）“-> List[str]”,规定返回的是列表，并且元素是字符串，但是错了也不会报错

from typing import List, Tuple, Dict

def add(a:int, string:str, f:float, b:bool) -> Tuple[List, Tuple, Dict, bool]:   

       。。。。。。。

【20】关键字参数和print()

print('shuchu1',end='')//本来会在结尾加换行符，但是加上end=‘’之后，将以‘’结尾，也就是不换行

print('canshu1','canshu2','canshu3')

print('canshu1','canshu2','canshu3',sep=',')    //sep=','    标识用，分割字符   

【21】global  

定义全局变量

【22】对于可能发生错误的地方的处理

使用try 和except处理

例如：

ZeroDivisionError

除(或取模)零 (所有数据类型)

def shicuo(canshu):

    try:

         return  2/canshu

     except ZeroDivisionError:    #ZeroDivisionError  这个是固定的，可以自己查一下都有哪些

          print('baocuo  分母为0了哈')

【23】列表---一个值

（1）spam=['zhi1','zhi2','zhi3','zhi4']     #spam变量被赋予一个列表值，但是列表本身又包含很多值

（2）列表的值得下标，spam[0]

(3)列表可以包含其他列表

spam=[['zhi1','zhi3'],['zhi4','zhi5']]

(4)负下标

spam[-1]  标识倒数第一个，-2倒数第二个。。。。。

（5）切片获取列表

spam[1:4]

spam[:4]

下面是从菜鸟教程复制来的。。。。。。

# -*- coding: UTF-8 -*-

s = 'abcdefg'
# 返回从起始位置到索引位置 2 处的字符串切片
print(s[:3]) # 输出 'abc'

# 返回从第三个索引位置到结尾的字符串切片
print(s[3:]) # 输出 'defg'

# 字符串逆序输出
print(s[::-1]) # 输出 'gfedcba'

# 输出从开始位置间隔一个字符组成的字符串
print(s[::2]) # 输出 'aceg'
print(range(10)[::2])  # 输出偶数：[0, 2, 4, 6, 8]

# 它们也可以相互结合使用。
# 从索引位置 6 到索引位置 2，逆向间隔一个字符
print(s[6:2:-2]) # 输出'ge'

(6)获取列表的长度

len(spam)

(7)用操作符+    连接两个列表

（8）用del删除下标处的值

del spam[2]

(9)   +[]方式   //回头再看下这个

（10）前面说的range(4)类似于   [0,1,2,3]

可以 for i in  [0,1,2,3]

(11)  in  和not  in 操作符，表达式的值是布尔类型

'0'  int  [0,1,2,3]

返回True

(12)多重赋值

aiyou=[0,1,2]

ni,wo ,ta =aiyou     #这样 ni=0,wo=1,ta=2

（13）列表操作符   

+=    连接字符串

 *=    复制字符串

（14）index方法，如果一个值存在就返回下标

liebiao_name.index('cunzaime')

(15)append() 方法

liebiao_name.append("jiashangyige")

(16)insert()方法

liebiao_name.insert(1,'charuyigezhi')

（17）remove（）方法

liebiao_name.remove('shanchuyige')

(18)sort()  排序

liebiao_name.sort()    //默认正序   ，加参数liebiao_name.sort(reverse=True) 则逆序

（19）

【24】类似列表的类型，字符串和元祖

（1）字符串可以看做是单个文本字符列表，类似的可以进行下标取值、切片、for、len（）、in 、not in 操作符

（2）字符串是“不可变”的数据类型。

 

（3）元组    用（），像字符串一样不可变

【25】list（）    和tuple（）函数的转换

tuple (['cat','dog'])

list(('cat','dog'))

【26】将列表复制给 一个变量时，只是将列表的引用赋值给了该变量。//变量中的值，指向了同一个列表呗

//对于可变的数据类型的值，变量保存的只是列表值的引用，对于字符串和元祖这样不可变的数据类型，变量保存的就是值本身。

（2）copy（） 函数，不只是拷贝引用，修改cheese不影响原来的spam 

cheese=copy.copy(spam)

(3)如果要复制的列表中包含了列表，就需要使用copy.deepcopy()

【27】字典：许多值得集合，但是与列表不同，字典的索引可以使用多种数据类型，不止是整数。索引被称为‘键’，关联的称为“‘值’”

{‘’：‘’ ，‘’：‘’}  //可以构造出奇怪的应用，比如{'mingzi':"shengri}

（1）字典的表项不是排序的所以不能用切片

(2)  key()   ,values() ,items()  可以用于for 循环

for k in  dicname.values()   //这里可以是  dicname.key() ，dicname.items() ，

     print(k)

（3）也可以用

 for  k ,v in dicname.items()

      print('key='+k+'value'+str(v))

(4)in  not in

'jianzhi' in dicname.values()

返回True 或者False

(5)取键值，当不存在试用一个默认的代替

dicname.get('key1',2)

（6）默认值

dicname.setdefault('jian','morenzhi')

（7）字典和列表可以互相嵌套的,赋值如下

dict={'a':['shuchujieguoshizhege','0']}
print(dict['a'][0])   //输出为   shuchujieguoshizhege

（8）字典赋值

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

dict['Age'] = 8                      # 更新

dict['School'] = "RUNOOB" # 添加

【28】字符串：以单引号或者双引号

（1）转义字符

到斜杠  \       

例如    \'   则打印为  '

（2）"""  """

三重引号，所有的都被认为是字符串的一部分。

（3）切片            /spæm/ 

spam='helllo world'

>>>spam[1:4]   //不包括4的哈

ell

（4）upper()   lower()     

islower()      //返回布尔值哈

（5）startwith （）   endwith()

'hello'startwith("he")    //返回True

(6)join   和 split（）

将字符串列表连起来作为一个单独的字符串   //转化为字符串

比如：>>>  ','join(['lian','qi','lai','yongdouhao','yebuzhidaohuibuhuiyourenkanwoxiedewenzhanghaahahhah'])

输出   lian,qi,laiyonghao.......

(7)rjust（20）   ljust()  center()     //第一个参数是，放在一共多少个字符的字符串中，第二个参数是填充的内容、

通过加空格方式左对齐右对齐  居中对齐

（8）strip()      rstrip ()    lstrip()    //删除左边右边  两边的空白符   、或者指定删除的内容   比如  strip ('shanchu')

（9）pyperclip  模块拷贝粘贴字符串  

pyperclip.copy('xxxx')

pyperclip .paste()

【29】re 模块

【30】不同文件下函数的调用

（1）

import a#应用模块 
from a import func #引用模块中的函数 
func（） #这里调用函数就不需要加上模块名的前缀了

（2）

import a #引用模块 
a.func( )

（3）

1. class A:

2. def __init__(self,xx,yy):

3. self.x=xx

4. self.y=yy

5. def add(self):

6. print("x和y的和为：%d"%(self.x+self.y))

B.py文件：

1. from A import A

2. a=A(2,3)

3. a.add()

【31】cmd

（1）最原始的方法

import os

os.system("ls")

（2）使用Popen模块产生新的process

****************************************这个以后再补充

（3）getoutput

>>> commands.getoutput('pwd')

'/home/oracle'

（4）getstatusoutput
返回两个元素的元组tuple(status, result)，status为int类型，result为string类型。

>>> commands.getstatusoutput('pwd')

(0, '/home/oracle')

【32】.join

形式：                     yongwo.join('bei','lian','jie','de','jigezifu')

例如：  str = "-"; seq = ("a", "b", "c"); # 字符串序列 print str.join( seq );

以上实例输出结果如下：

a-b-c

【33】这条不用看了，是留给自己的笔记。。。。

pdlist(cls, '/c0', 'SATA', 'HDD') -> tuple:

        command = ' '.join.((cmd_product, ctl, SHOW,grep -iw {} )).format(
            interface)
        # fegemingling的作用是把输入的参数用空格连接起来
        # 这句话的意思就是 satori64 /c0 show | grep -iw ugo | grep -iw {SATA} | grep -iw {HDD}
        state, output = subprocess.getstatusoutput(command)
        return state, output

【34】.format 

（1）常用的方法

"{1} {0} {1}".format("hello", "world") # 设置指定位置 'world hello world'

（2）# 通过字典设置参数

site = {"name": "菜鸟教程", "url": "www.runoob.com"}

print("网站名：{name}, 地址 {url}".format(**site))

（3）# 通过列表索引设置参数

my_list = ['菜鸟教程', 'www.runoob.com']

print("网站名：{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是必须的

【35】python 中一些常用函数     //这部分都是网上收集的。。。。。  

（1）locals()    函数会以字典类型返回当前位置的全部局部变量。

def fun(a, b):
  x = 20
  y = 30
  sum = x + y
  prod = x * y
  formatStr = '{x} + {y} = {sum}; {x} * {y} = {prod}.'
  print(formatStr.format(**locals()))

# print: '20 + 30 = 50; 20 * 30 = 600.'

（2）inspect.stack()     // 这个函数是用来获取栈的全部调用信息，如下面函数用于获取函数名字

def debug():     import inspect     print(inspect.stack()[0][3])     print(inspect.stack()[1][3])     caller_name = inspect.stack()[1][3]     # print("[DEBUG]: enter {}()".format(caller_name) )   def say_hello():     debug()   if __name__ == '__main__':     say_hello() ============================= 书出具结果是 debug say_hello

【36】 Python的f-strings格式化，

# 以 f开头表示在字符串内支持大括号内的python 表达式，相当于 format() 函数

name = "Tom"
age = 3
f"His name is {name}, he's {age} years old."
>>>"His name is Tom, he's 3 years old."

【37】jupyter

（1）y  和 m   切换注释和代码（code   和markdown的切换也就是）

（2）## 标题     

（3）raw nbcvonvert 这个别人说是用来显示不运行的代码，先这么理解

【38】python  二维数组

array= [([0] * 3) for i in range(3)]
array[1][1] = 2
此时 array= [[0, 0, 0], [0, 2, 0], [0, 0, 0]]

【39】[str(i) for i in ls1]    列表生成式

ls2 =[str(i) for i in ls1]

等价于

1 2 3

ls2 = [] for i in ls1:     ls2.append(str(i))

【40】cls   和self  的区别

1、self表示一个具体的实例本身。

如果用了staticmethod，那么就可以无视这个self，将这个方法当成一个普通的函数使用。

2、cls表示这个类本身。

【41】in  ///not in  

判断是否含有某个元素

【42】for 循环是可以在下面加一个else:   //比较常用的一个用法

for  i in []:

        --------

else:

          没有break 退出循环，则会执行的代码。

【42】break  ，continue

break:退出循环

continue: 继续执行

【43】*     + 

字典 不能用  * 与 +

 

【44】切片

"123df4dsf4"[::-2]      

字典不能切片   

切片可以倒序

开始 结束  步长

zifuchua[0:8:1] //步长是1

zifuchuan[::-1]   //逆序， 步长为-1

【45】python  公共方法

len

del   //  del[1]

max  //返回容器中的最大值    max（shuzu）  ,max(zidian) 对字典是是对key进行比较

min

cmp// 比较大小

【46】比较运算符

可以对裂变，元祖，进行比较;  不能比较字典

(1,2,3)  > (4,5,6)

【47】extend   append     +

        （1）

[1,2,3].append([3,9])

+ 号 ，生成新的元组  ;append不生成新的

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

 

        （2）

[1,2,3].extend([3,9])

extend 不生成新元素

[1,2,3,3,9]

【48】

 

参数解释引用了 

https://zhidao.baidu.com/question/367559039025445444.html?qbl=relate_question_0&word=def%20%28%2A%2A%29%20python