python语法速成方法_30分钟学完Python基础语法

请注意,本文编写于 637 天前,最后修改于 624 天前,其中某些信息可能已经过时。

之前学了一些,现在全忘了。有时间所以又重新看了一下,并做以下记录

有一门面向对象语言的基础,30分钟足够看一遍Python的基础了

基础语法# 缩进取代大括号

# 用换行取代分号,也可以使用分号,无所谓

# 输出

print();

# 输入

input();

# 注释

#单行注释

"""

多行注释1

"""

'''

多行注释2

'''

# 申明变量

直接写字母就行与数字、下划线组合即可,不是保留字即可。

# if

if true:

print("true")

else:

print("false")

# while

i = 0;

while i <= 1:

#do something

print("cicle")

i+=1

# for

languages = ["C", "C++", "Perl", "Python"]

for x in languages:

print (x)

# range

range(5)函数返回数字0~4的数组

range(5,9) 函数返回数字5~8的数组

range(0,10,3) 函数返回从数字0开始,递增3,直到最后一个数字小于10的数字数组

range(-10,-100,-30) 函数返回从-10开始,递增-30,直到最后一个数组大于-100的数字数组

# for + range 带索引遍历数组

a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']

for i in range(len(a))

print(i,a[i])

# while 带索引遍历数组

i = 0;

length = len(a);

while i < a:

print(i,a[i])

i+=1

# for + enumerate 带索引遍历数组

for i,value in enumerate(a):

print(i,value)

# 列表list

# python list 和java list性质很类似,而不是数组,它的大小可变,但是Python列表的元素可以使把不同的数据类型,非常灵活

# 创建新的list

list1 = []

list2 = ['bob',1,true]

# 增加元素

list1.append(233)

list1.insert(0,666) #插入到0位置,原来元素依次后移

# 删除元素

list2.pop() #删除末尾的元素

list2.pop(0)

# 修改元素 = 直接赋值

# 访问指定位置元素

list1[2]

list1[-1] #表示最后一个元素

# 切片(返回一个子列表)

list2[0:2] #表示从索引0到1的元素

list2[-2:-1] #表示倒数第二个元素

list2[:3] #表示从0到2

list2[1:] #表示从1到结尾

# 元组tuple

# 与list列表区别是,tuple一旦初始化就不能修改。

# list使用[]方括号,tuple使用()圆括号

# 定义时候,只有一个元素,需要加一个,,避免歧义

t = (1,)

# 字典dict

# dict 和 java的map很类似。键值对,Python的dict很类似json的语法

# 定义

d = {'age':62, 'sex':'male'}

# 访问值

d['age']

# 判断key是否存在

d.get('name') #默认不存在返回none

d.get('name',-1) #指定不存在时候返回-1

'name' in d #不存在时候返回false

# 删除key

d.pop('sex')

# 集合set

# 和java的set性质很类似,也是没有重复元素的集合。

# 定义

s = set([1,1,2,2,2,3,3,'sex'])

# 添加元素

s.add(4)

s.add(4) # 重复元素添加操作不会生效

# 删除元素

s.remove('sex') #参数是set元素的值,而不是索引

# 函数

# 定义函数

def my_function(x):

print(x);

# 调用函数

高级特性

列表生成式和生成器列表生成器

一种快速生成一个指定条件的列表的语法。

第一个例子:生成数字0~10的列表,可以使用range(0,11)函数,这个并不是列表生成器,只是引出这个概念。

第二个例子:生成[1x1, 2x2, 3x3, ..., 10x10] 这样乘积结果形成的列表,普通写法是一层循环:l = []

for x in range(1,11):

l.append(x*x)

# 或者下面的循环

i = 1

while i < 11:

l.append(i*i)

i+=1

现在使用列表生成式只需要一句代码:[x*x for x in range(1,11)]

仔细看下上面代码,可以发现,就是把l.append(x*x)替换成x*x,并写在了for循环前面,而且整体用列表的符号[]包裹起来。

还可以更近一步,在for循环后面,写if语句,进一步筛选需要生成的元素:[x * x for x in range(1, 11) if x % 2 == 0]

# [4, 16, 36, 64, 100]

可以说,列表生成式就是一种语法的简化,没什么新的功能。生成器

列表生成式是真实返回一个生成好的列表。

但是如果我们需要生成的列表特别大,被逼入100万的成员,但我们只需要打印前几个元素,后面那个多成员所占用的空间就浪费了:L = [x * x for x in range(1000000)]

print(L[0])

print(L[1])

上面写法就是非常浪费,要遭到我们谴责的。可以用下面写法:g = (x * x for x in range(1000000))

next(g)

next(g)

这种写法的返回的并不是一个列表,而是一个生成器g。生成器就好比一个记住规则的工具,一开始并不会生成任何元素,通过调用next()一个个的生成数组元素。

加入我想生成10个元素,我可以迭代生成器:g = (x * x for x in range(10))

for x in g:

print(x)

上面语法可以创建一个生成器,还可以通过yield关键字使一个函数成为生成器:def odd():

print('step 1')

yield 1

print('step 2')

yield(3)

print('step 3')

yield(5)

g = odd()

next(g) # step 1

next(g) # step 2

next(g) # step 3

next(g) # StopIteration

同样可以使用for循环迭代这个生成器:for x in odd():

print(x) # 依次返回1 3 5

一个函数成为生成器,使用next调用函数,遇到yield语句会返回yield申明的值(常量/变量)。再次调用next从上次返回的位置继续,直到遇到下一个yield语句。

迭代器

首先需要区分两个概念:迭代器(Iterator)和可迭代对象(Iterable):可迭代对象:可以使用for遍历,但是不能被next()调用,不断的返回下一个值。

迭代器:可以通过调用next(Iterator),不断返回迭代器内部的值

通过isinstance([变量] , Iterator)或isinstance([变量] , Iterable) 判断变量是否是迭代器或是可迭代对象

list、dict、str本身不是迭代器,可以通过iter(Iterable)返回迭代器对象

生成器本身就是迭代器对象。l = [1, 2, 3, 4, 5]

lIter = iter(l)

next(lIter) # 返回1

函数式编程

装饰器

设计模式里有一个设计模式就是装饰器模式,其实很容易理解,就是对函数进行扩展功能。但是又不想通过继承的方式。

用装饰器函数把原函数包裹起来,先执行装饰器的功能,再调用原函数。

所以装饰器的参数首先需要原函数func_name,而且装饰器内部还需要定义一个函数wrapper,参数是*args, **kw,表示任意参数,用来接收调用原函数的参数。

举个例子,定义一个log的装饰器,可以装饰在任何函数上(方式是在需要装饰的函数顶部写@装饰器名称),执行原函数,会输出该函数的调用信息:def log(func):

def wrapper(*args, **kw):

print("调用函数%s()"% func.__name__)

return func(*args, **kw)

return wrapper

@log

def now(str):

print("一个测试函数 + %s" % str)

当我们执行now("哈哈"),实际上执行的是log(now("哈哈")),然后log函数内部调用wrapper("哈哈"),先打印测试时间,再执行了now("哈哈")

装饰器也可以传值,但是装饰器内部再多一个函数,用来接收需要装饰的函数名:def log(text):

def decorator(func):

def wrapper(*args, **kw):

print("调用函数%s()时间为,测试文字 %s" % (func.__name__ ,text))

return func(*args, **kw)

return wrapper

return decorator

@log("自定义文字")

def now(str2):

print("一个测试函数 + %s" % str2)

这样调用now("哈哈"),实际上调用了log("自定义文字")now("哈哈"),然后执行decorator(now("哈哈")),下面的调用过程和之前一样了。

被装饰器修饰的函数,会有一个问题:打印他的函数名称会有问题:

比如now.__name__,会输出wrapper,我们可以在wrapper的函数,上面写一句:import functools

def log(func):

@functools.wraps(func)

def wrapper(*args, **kw):

print("调用函数%s()"% func.__name__)

return func(*args, **kw)

return wrapper

这句注解自动会帮我们wrapper.__name__ = func.__name__赋值。

面向对象编程

我们用java的类概念来引入Python的面向对象的所有概念:类class Student(object):

def __init__(self, name, score, sex):

self.name = name

self.score = score

self.__sex = sex;

def print_score(self):

print('%s: %s' % (self.name, self.score))

st = Student("hewro",120,"male")

print(st.name)

st.print_sore()

从上面代码,我们可以看出:成员变量是在__init__中定义,而不是直接申明变量

构造函数名称是__init__,Python不支持函数重载,自然只能有一个构造函数了。而且第一个参数一定是self,生成实例的时候,不需要手动调用该参数。

在类的内部使用本身的变量,需要在函数第一个参数添加self,很麻烦

继承父类的写法不是extend,而是(父类)

python 的私有变量定义也没有关键字,只是定义变量名称前面加两个下划线__,如__sex,就无法直接打印std.__sex关于多态

我们知道多态是继承带来的一个很好特性。java、Python都有。但是Python本身变量不需要申明类型,所以多态实现,并不一定需要是定义父类的子类,而只要是该对象也拥有指定的方法即可(即鸭子类型)。

比如我们有一个Animal的父类,还有继承Animal的Dog和Cat 子类class Animal(object):

def run(self):

print('Animal is running...')

class Dog(Animal):

def run(self):

print('Dog is running...')

class Cat(Animal):

def run(self):

print('Cat is running...')

class Tortoise(Animal):

def run(self):

print('Tortoise is running slowly...')

# 这个函数的参数实际上是没有申明类型的

def run_twice(animal):

animal.run()

animal.run()

所以执行run_twince()参数可以是dog实例,也可以是Tortoise的实例,虽然Tortoise并不继承于Animal。

你可能感兴趣的:(python语法速成方法)