Python基本语法一览

Python基本语法一览

Python3.7

Windows10

0、特性

1、动态类型。

2、两种模式，交互模式和文件模式。

3、严格的缩进来控制语句范围及顺序。

4、即是面向对象语言也是面向过程语言。

Python中没有{}，使用缩进来控制语句之间的关系。

一、变量、类型、流程控制、运算符

1.1、变量、类型

Python是动态类型的原因，不需要指定变量类型。直接复制即可：

name="Hello" #字符串

num=18   #int类型

f=1.3  #float类型

c=1+5j #complex类型

b=True #bool类型

b1=bool(1) #  Python3中的True即1，false就是0，bool型可以和数字进行运算

print(type(name)) #type是内置函数，返回类型
print(type(num))
print(type(f))
print(type(c))
print(type(b))
print(type(b1))

-----------------------------------------------------------------------------
<class 'int'>
<class 'float'>
<class 'complex'>
<class 'bool'>
<class 'bool'>

Python3 中有六个标准的数据类型：

• Number（数字）（ int、float、bool、complex（复数））
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

Python3 的六个标准数据类型中：

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

这里的可变不可变和其他语言的值类型、引用类型相似。有关深浅拷贝问题。

list_1=[1,2,3,4] #列表可以切片

tur=('a','b','c')  #元祖

s={1,3,5,3} #集合

d={name:"tom",tur:list_1,8:8} #字典
#键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

print(type(list_1))
print(type(tur))
print(type(s))
print(type(d))

-----------------------------------------------------------------------------

<class 'list'>
<class 'tuple'>
<class 'set'>
<class 'dict'>

集合中的元素具有无序性，所以无法切片，字典通过键访问数据。

而字符串、列表、元组都可以索引、切片等。

print(name[0:3])  #  切片范围[start:end)
print(list_1[0:3])
print(tur[0:2])
print(s)
print(d[name])

--------------------------------

Hel
[1, 2, 3]
('a', 'b')
{1, 3, 5}
tom

1.2 、类型特点

字符串是不可变类型，赋值后不可更改，如果重复赋值，那么重新赋值后的字符串变量是一个新的变量。

str="hello py"

str1=str  #str1的值为str
str1="oo"   #str1的值为oo,此时的str1是一个新的str1

print(str1) # oo
print(str)  # hello py

列表是可变类型，也可以说是引用类型，这种赋值可以说是深拷贝，修改了数据后会影响原来的数据。

list_s=list("python")

list_l=list_s  #深拷贝

list_l[0:4]=list("java") #修改

print(list_l) #['j', 'a', 'v', 'a', 'o', 'n']
print(list_s) #['j', 'a', 'v', 'a', 'o', 'n']

可变数据类型也提供了浅拷贝函数，拷贝出来的数据修改后不会影响原数据。

list_c=list_s.copy() #  浅拷贝

list_c[0:5]=list("c++")#修改数据

print(list_c) #['c', '+', '+', 'n']
print(list_s) #['j', 'a', 'v', 'a', 'o', 'n']

1.3、流程控制

if 、else、elif条件语句

x=input("input data :")

if x.count('o')>1:
    print("The input's str: %s"%x)
elif x.count('o')==1:
    print("The one  : ",x)
else:
    print("error data")

for 、while循环

Python有两种循环方式：

i=1
while i<10:
    print(i,end="-") #1-2-3-4-5-6-7-8-9-
    i+=1

l=list("Python")
for i in l:
    print(i,end='-') #P-y-t-h-o-n-

range函数

range函数式内置函数，会生成数列,也经常和for循环一起使用：

n=list(range(5))
print(n)  #[0, 1, 2, 3, 4]


for n in range(0,10,2):
    print(n,end='-')  #0-2-4-6-8-

1.4、运算符

算数运算符

print(5*2) #乘法
print(5**2) #幂次方

print(5/2) #  真除法
print(5//2) #除法、向下取整
print(-5%4) #模运算

10
25
2.5
2
3

逻辑运算符

print(3 and 4)  #布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。
print(1>0 and 3>0)


print(1>0 or 3<0)#布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。
print(1<0 or 3<0)


4
True
True
False

位运算符

print(2&3) #与运算
print((3>2)&(1>0))#与运算

print(1^3) #异或
print(3|5) #或

2
True
2
7

其他运算符

in 、not in
is 、not is
.............................

二、函数、内置函数

1、函数

函数式具有相关功能的代码，在Python中使用def关键字进行定义：

如下：

def f1():
    print("this is a func which don't parameter",end='\n---------------\n')

def f2(a,b):
    print("this is a func which has 2 parameter that is ",a,b ,end="\n-------------------\n")

def f3(a,b=3):
    print("this is a func which has 2 parameter that is ",a,b ,end="\n-------------------\n")

    
f1()
f2(1,2)


f3(1)
f3(1,6)

#这些都是合法函数、Python函数不支持重载，但支持覆盖，同名函数会覆盖掉前面的函数。

参数种类如下：

• 必需参数
• 关键字参数
• 默认参数
• 不定长参数

前三个如下：f3函数同时满足：

f3(b=10,a=9)
#   函数有参数则必须传入、可以在形参中指定默认参数，当然这个参数可以不传入，如果传入则覆盖默认参数。

#通过关键字可以指定参数，否则需要按照顺序传参。

不定长参数中传入的参数数量不确定：

通过对参数前指定*号来声明不定长：

*则掺入的数据成为元组，**则成为字典。

def f4(a,*args):
    print("a: ",a)
    print(args) #(2, 3, 4, 5)

def f5(a,**args):
    print("a: ",a)
    print(args) #{'A': 2, 'b': 3, 'c': 4, 'd': 5}

f4("one",2,3,4,5)
f5("one",A=2,b=3,c=4,d=5) #此处需要注意命名冲突，传入的key不能和形参重名

2、匿名函数、Lambda表达式

有些函数用的少、或者功能较为简单，那么用匿名函数实现。Python中匿名函数使用lambda表达式实现。

lambda 函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,.....argn]]:expression

如下：

n=lambda x,y:print(x+y)
s=lambda :print("hello")
n(1,2) #3
s()    #hello

3、内置函数

Python有很多内置函数。

abs、sum、max、pow计算类

这部分用于辅助计算：

print(abs(-10)) #10
print(pow(2,3))  #8
print(sum((1,2,3)))  #6

list、dict、int、bin、ord转换类

这部分用于数据的转换：

>>> list("hello world")
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

>>> int(1.2)
1   
>>> bin(5)
'0b101'

>>> x=dict()
>>> x['name']="tom"
>>> x
{'name': 'tom'}

print、len、id、range 工具类

这部分是简化一些操作：

>>> len(x)
1
>>> id(x)
2595951301472

eval、exec等其他类

这部分各有功能，如eval帮助交互式操作：

>>> eval('1+2')
3

三、面向对象

1、类与对象

Python使用class关键字定义类，对象的创建无需关键字。

关于类中成员的访问，由__表示私有。

class Person:
    sum=0 #类成员变量
    def __init__(self,name,age,Id):
        self.name=name #对象变量
        self.__age=age
        self.__id=Id
        Person.sum+=1 #调用类成员
        
    #对象方法
    def show(self):
        print("hello ,I'm {0}".format(self.name))

    #专有方法__str__，打印对象时使用
    def __str__(self):
        return "{}:{},{},{},{}".format(self.__class__,self.name,self.__age,self.__id,self.__class__.sum)

    
p1=Person("Tom",18,1001000101) #创建对象
p1.show()                    #调用方法  
p2=Person("Jack",19,1001000102)
p2.show()

以上是一个简单的类，一个类的组成有以下部分：

专有方法	这部分是类自带的方法，像__init__()、del()、str()等
类成员变量	这是共享变量，类的每个对象共有
对象变量	每个对象自己的变量
对象方法	通过对象调用
静态方法	@staticmethod修饰，无默认参数，类和对象都可以调用
类方法	@classmethod装饰，至少传入一个cls，类和对象都可以调用
其他	对象.__dict__、__class__等属性

一个类：

class Person:
    sum=0 #类成员变量
    def __init__(self,name,age,Id):
        self.name=name #对象变量
        self.__age=age
        self.__id=Id
        Person.sum+=1 #调用类成员
        
    #对象方法
    def show(self):
        print("hello ,I'm {0}".format(self.name))

    #专有方法__str__，打印对象时使用
    def __str__(self):
        return "{}:{},{},{},{}".format(self.__class__,self.name,self.__age,self.__id,self.__class__.sum)

    
    @property  #修饰器，将方法修饰成属性，如p1.age即可调用该方法
    def age(self):
        print("Age of {0} is {1}".format(self.name,self.__age))


    @classmethod    #类方法、可加参数
    def cls(cls):
        print("classmethod----")
    
    @staticmethod  #静态方法，无参数
    def sta():
        print("staticmethod----")

  


p1=Person("Tom",18,1001000101)
p1.show()
p2=Person("Jack",19,1001000102)
p2.show()

print(p1)
print(p2)

p1.age 

p1.cls() #对象和类都能调用
Person.cls()

p1.sta()
Person.sta()

2、继承、多态

Python支持继承以及多继承。

子类（父类）:即可

class Man(Person):

    def __init__(self,name,age,Id):
        Person.__init__(self,name,age,Id) #调用父类方法
    
    def show(self):
        super(Man,self).show()    #继承父类方法

Python是动态类型的语言，对多态的某些特性并不支持。

这是函数或者是对象的方法，不支持重载，下方的方法会覆盖掉上面的方法。

 def show(self):
        print("hello ,I'm {0}".format(self.name))
    
 def show(self,arg):
        print(arg)