Python编程用法——基本语法

以你之姓@ 2022-09-03 14:18 221阅读 0赞

# 打印函数print #

打印函数作为Python的输出类型，可以观察变量以及代码在各阶段的运行情况。

print("ZX Python")

打印函数内字符串可以用逗号隔开，在打印时就将逗号识别成空格

print("Python","ZX","Test")

执行结果

Python ZX Test

## 打印换行 ##

打印换行可以用’’'将字符串两边括起来使用，也可以通过\\n换行

print('''ZX Test Python''')
    
    print("n Test \nPython")

执行结果

ZX
    Test
    Python
    n Test
    Python

## 打印格式化 ##

在变量格式化中有详细说明，具体与C/C++相同

print("%s:%.2f,%d" % ("ZX",3.14159,23))

执行结果

ZX:3.14,23

另外Python可以用format函数进行传参，参数可以不用按照传参的顺序进行定位，通过\{n\}的下标方式进行定位参数通过:定义详细的参数，例如:.2f控制浮点型的精度。

print("format:int = {1},pai = {2:.2f},name = {0}" .format("ZX_Python",inttest,floattest))

执行结果

format:int = 20,pai = 3.14,name = ZX_Python

## 打印文件信息 ##

获取文件名，行号，路径，用到的模块对应加上

import sys,os
    
    def printFileInfo():
    	print("func name:",sys._getframe().f_code.co_name)
    	print("line:",sys._getframe().f_lineno)
    	print("file name:",__file__)
    	print("file basename:",os.path.basename(__file__))
    	print("file dirname:",os.path.dirname(__file__))
    	print("file realpath:",os.path.realpath("."))
    	print("file abspath:",os.path.abspath("."))
    	print("file abspath:",os.path.abspath("test.txt"))  
    
    print("get func name:",printFileInfo.__name__)
    printFileInfo()

执行结果

get func name: printFileInfo
    func name: printFileInfo
    line: 17
    file name: g:\share\Code\Test_Python\Pymain.py
    file basename: Pymain.py
    file dirname: g:\share\Code\Test_Python
    file realpath: G:\share\Code\Test_Python
    file abspath: G:\share\Code\Test_Python
    file abspath: G:\share\Code\Test_Python\test.txt

# Python传参 #

Python传参通过sys.argv接收是一个list组合，需要包含模块sys

print("argv print:")
    
    for value in sys.argv:
    	print(value)

执行结果

$ python Pymain.py name1 ../ Pyfunc/
    argv print:
    Pymain.py
    name1
    ../
    Pyfunc/

# 条件判断 #

Python条件判断是以if，elif，else为关键字判断。**关键字带的判断条件后面需要加“:”符号，判断语句的范围以缩进为准。**

ifValue1 = 0
        ifValue2 = ""
        ifValue3 = 2 > 3
    
        if ifValue1:
            print("Test1","OK",ifValue1)
        elif ifValue2:
            print("Test2","OK",ifValue2)
        elif (ifValue3):
            print("Test3","OK",ifValue3)
        else:
            print("Test","NO")

执行结果

Test NO

判断为真的条件：非0，非空字符串，非空数组，True  
Python判断条件可以不加括号，但为了语法标准以及严谨，在判断条件中需要添加括号。

# 循环 #

循环的使用方式与其他语法大体相同，其中break为退出循环，continue为跳过本次循环，到达下一次循环。

## for in格式 ##

Python采用for in格式循环，依次扫描整个数组list，将变量赋值到定义的value变量中。

testarray = ["ZX",3.14,"A","Python",12]
    for testvalue in testarray:
    	print(testvalue)

执行结果

ZX
    3.14
    A
    Python
    12

若要访问循环中的变量，则需要利用enumerate函数获取到循环中的下标

testarray = ["ZX",3.14,"A","Python",12]
    
    for testindex,testvalue in enumerate(testarray):
    	if(testindex < 2):
    		print("index:",testindex,testvalue)
    	if(testindex == 2):
    		print("continue:",testindex)
    		continue
    	if(testvalue == "Python"):
    		print("break:",testvalue)
    		break
    
    print("for in end")

执行结果

index: 0 ZX
    index: 1 3.14
    continue: 2
    break: Python
    for in end

## while格式 ##

while使用方法与C/C++相同，但Python不支持自増与自减变量

windex = 10
    while(windex):
    	if(windex < 7):
    		print("break:",windex)
    		break
    	print("while index:",windex)
    	windex -= 1
    
    print("while end")

执行结果

while index: 10
    while index: 9
    while index: 8
    while index: 7
    break: 6
    while end

# 变量 #

Python为解释性语言，变量类型不区分int、float甚至字符串，类等类型。也无需定义前缀关键字类型，具体是确定初始化的是相应的类型，解释器就会赋予该相应的类型。

## 常用变量 ##

inttest = 20
    floattest = 3. 14159
    hextest = 0xFD
    chartest = 'A'
    strtest = "str Python"
    falsetest = 1 < 0
    truetest = 5 > 2
    
    print("inttest =",inttest)
    print("floattest =",floattest)
    print("hextest =",hextest)
    print("chartest =",chartest)
    print("strtest =",strtest)
    print("falsetest =",falsetest)
    print("truetest =",truetest)

执行结果

inttest = 20
    floattest = 3. 14159
    hextest = 253
    chartest = A
    strtest = str Python
    falsetest = False
    truetest = True

## 枚举 ##

枚举需要包含枚举的模块

from enum import Enum
    
    enumType = Enum('ZX_TEST', ("One", "Two", "Three"))
    
    def EnumTypeFunc():
        #遍历获取枚举值
        for name, member in enumType.__members__.items():
            print("name:",name,"---number name:", member,"---value:", member.value)
    
        #自定义枚举值
        class Cenum(Enum):
            STEP1 = 5
            STEP2 = 7
            STEP3 = 11
    
        for name, member in Cenum.__members__.items():
            print("name:",name,"---number name:", member,"---value:", member.value)

执行结果

name: One ---number name: ZX_TEST.One ---value: 1    
    name: Two ---number name: ZX_TEST.Two ---value: 2    
    name: Three ---number name: ZX_TEST.Three ---value: 3
    name: STEP1 ---number name: Cenum.STEP1 ---value: 5  
    name: STEP2 ---number name: Cenum.STEP2 ---value: 7  
    name: STEP3 ---number name: Cenum.STEP3 ---value: 11

## type获取变量类型 ##

import types
        
    #获取类型
    print("get type")
    print(type(2))
    print(type(3.14))
    print(type('A'))
    print(type("Python"))
    print(type(True))
    
    def func():
    	print("func")
    
    print(type(func))
    
    print(type([1,2,3]))
    print(type({ 1:"Test",'A':3.14}))
    print(type((2,3,5,7)))
    
    #类型比较
    print("cmp type")
    print(type(2) == int)
    print(type(2) == type(3))
    print(type("Python") == str)
    print(type("Python") == type(3.14))
    print(type(False) == bool)
    print(type(func) == types.FunctionType)
    print(type(func) == type(lambda x: x + 1))

获取函数类型需要用到  
import types

执行结果

get type
    <class 'int'>
    <class 'float'>
    <class 'str'>
    <class 'str'>
    <class 'bool'>
    <class 'function'>
    <class 'list'>
    <class 'dict'>
    <class 'tuple'>
    cmp type
    True
    True
    True
    False
    True
    True
    True

## isinstance判断已知变量类型 ##

使用isinstance判断已知变量的类型，若类型已知返回true，不同返回false  
也可以用来对类的继承判断

print("int:",isinstance(2,int))
    print("float:",isinstance(3.14,float))
    print("str:",isinstance("Ptyhon",str))
    print("func:",isinstance(lambda x: x + 1,types.FunctionType))
    
    print("list:",isinstance([2,3,5,7],list))
    print("dict:",isinstance({ 1:"Test",'A':3.14},dict))
    print("tuple:",isinstance((2,3,5),tuple))
    
    class CBase(object):
    	def show(self):
    		print("Base")
    
    class CTest(CBase):
    	def show(self):
    		print("Test")   
    print("class type:",type(CBase))
    print("class isinstance:",isinstance(CBase,type))
    
    test = CTest() 
    #类的继承判断
    print("class test:",isinstance(test,CTest))
    print("class base:",isinstance(test,CBase))

执行结果

int: True
    float: True
    str: True
    func: True
    list: True
    dict: True
    tuple: True
    class type: <class 'type'>
    class isinstance: True
    class test: True
    class base: True

## 类型转换 ##

print("int =",int(1.618))
    print("str int =",int("100"))
    print("hex int =",int('0xF23',16))
    print("bin int =",int('0b1011010',2))
    print("float =",float("100.76"))
    print("hex =",hex(253))
    print("str =",str(3.14))
    print("bool =",bool(5))
    print("bool =",bool(''))
    print("bin =",bin(23))
    print("bin len =",(23).bit_length())

执行结果

int = 1
    str int = 100
    hex int = 3875
    bin int = 90
    float = 100.76
    hex = 0xfd
    str = 3.14
    bool = True
    bool = False
    bin = 0b10111
    bin len = 5

# 逻辑运算 #

print(5 + 3)
        print(3 - 5)
        #除法
        print(5 / 3)
        print(3 / 5)
        #求商
        print(5 // 3)
        #求余
        print(5 % 3)
        #幂
        print(5 ** 3)
        
        #复数
        complexValue = 2 + 3j
        print("real:",complexValue.real)
        print("imag:",complexValue.imag)
        #共轭复数
        print("conjugate:",complexValue.conjugate())
        
        print(complex(7,-11) + (5 + 13j))

执行结果

8
    -2
    1.6666666666666667
    0.6
    1
    2
    125
    real: 2.0
    imag: 3.0
    conjugate: (2-3j)
    (12+2j)

# 字符串 #

Python用单引号或双引号都能表示字符串。为了与C/C++统一格式，单个字符用单引号，字符串用双引号。字符串拼接可以直接用+号进行拼接。

strTest = "Python" + 'A'
        strTest += " ZX test"
        print(strTest)

执行结果

PythonA ZX test

## 获取字符ASCII编码 ##

函数ord获取字符的ASCII编码，函数chr将ASCII编码转换成对应的字符

print(ord('A'))
        print(chr(65))

执行结果

65
    A

## 字符串索引 ##

字符串的索引以0下标开始，索引数值不能超出字符串长度，负值表示获取倒数第几个字符

strIndex = "PythonStringTest"
     print(strIndex[3],strIndex[-1])

执行结果

h t

## 字符串切片 ##

字符串下标通过符号“:”对字符串进行切片，“:”两边的下标分别对应获取字符串的范围。获取的格式是\[n:m\]，获取的字符串范围为n~(m-1)  
字符串只能从左到右获取，不能从右到左获取，例如\[5:1\]则为非法，获取到的字符串为空值。  
![在这里插入图片描述][a702b41e865c4aca865f0d8db4ecce35.png]

strIndex = "PythonStringTest"
        print(strIndex[3],strIndex[-1])
    
        #取值范围左边为闭区间，右边为开区间 [x:y)
        print(strIndex[3],strIndex[-1])
    
        #取值范围左边为闭区间，右边为开区间 [x:y)
        print("str 3~6:",strIndex[3:6])
        print("str ~4:",strIndex[:4]) #从0开始
        print("str 5~:",strIndex[5:]) #从5开始，直到末尾
        print("str 2~-2:",strIndex[2:-2])
        print("str -16~-13:",strIndex[-16:-13])
        print("str 2~13, step = 3:",strIndex[2:13:3]) #范围[2,13)，每隔3个步长取一个数
        print("str 5~1:",strIndex[5:1]) # 无效

执行结果

str 3~6: hon
    str ~4: Pyth
    str 5~: nStringTest
    str 2~-2: thonStringTe
    str -16~-13: Pyt
    str 2~13, step = 3: tnrg
    str 5~1:

## 大小写转换 ##

#全部转换成大写
        print("str upper:",strIndex.upper())
        #全部转换成小写
        print("str lower:",strIndex.lower())

执行结果

str upper: PYTHONSTRINGTEST
    str lower: pythonstringtest

## 异常处理 ##

Python代码执行时出现的错误，会议抛异常的形式表现出来

def tryErrorFunc():
        value = 2 / 0

![在这里插入图片描述][99bb0eb1b32e4987babfa65cb89a53e3.png]  
Python运行时抛出了ZeroDivisionError异常

## 接收异常 ##

Python用try和except组合接收异常

接收ZeroDivisionError异常

try:
    	value = 2 / 0
    
    #接收ZeroDivisionError异常
    except ZeroDivisionError as error:
    	print(error)
    #接收全部异常，防止遗漏 
    except Exception as error:
    	print("Exception Error:",error)
    #没有发生异常，正常执行的代码，必须放在所有异常处理后面
    else:
    	print("value =",value)
    #接收异常结束，可以省略 
    finally:
    	 print("except end")

执行结果

division by zero
    except end

接收全部异常，防止遗漏

value = 2 / '3'

执行结果

Exception Error: unsupported operand type(s) for /: 'int' and 'str'
    except end

没有异常

value = 2 / 4

执行结果

value = 0.5
    except end

## 抛异常 ##

Python对一些常用的错误会抛出异常，也可以通过函数自定义抛异常。  
Python用raise抛异常，抛异常关键字需要用Python内置的的异常，内置异常都派生自 Exception 的类。

def RaiseErrorFunc():
        try:
            value = 2 / 4
    
            if value < 1:
                raise ValueError("Value:%f is error" % value)
        
        #接收ValueError异常
        except ValueError as error:
            print(error)
    		#若本函数无法处理，就将该异常继续往上抛
            raise 
        except Exception as error:
            print("Exception Error:",error)
        else:
            print("value =",value)   
        finally:
             print("except end")  
    
    try:
    	RaiseErrorFunc()
    except Exception as error:
    	   print("Exception Error:",error)

执行结果

Value:0.500000 is error
    except end
    Exception Error: Value:0.500000 is error

## 自定义异常 ##

自定义异常需要继承至Exception类

class TestError(Exception):
        def __init__(self, expression, message = None):
            self.expression = expression
            self.message = message
    			
    try:
        raise TestError("Test Error","Try again")
    except TestError as error:
        print("Error info:",error.expression)
        if error.message != None:
            print("Error message:",error.message)     
    except Exception as error:
        print("Error info:",error)

执行结果

Error info: Test Error
    Error message: Try again

[a702b41e865c4aca865f0d8db4ecce35.png]: /images/20220829/4e99e53f95ca4de0bf8e1a9ac62f4ad1.png
[99bb0eb1b32e4987babfa65cb89a53e3.png]: /images/20220829/94fbe580f44b46c0b40623a2df457c71.png