python基础入门(1/3)

基础知识

缩进

通过空白符（制表符或空格）来组织代码。建议用4个空格作为默认缩进量。（也可以以分号结束，一般不建议）

Python的对象模型一致性。

注释：

单行注释：#

多行注释："""或者'''，（与多行字符串一样）

变量赋值和按引用传递：

赋值又称绑定，python中对变量赋值时，其实是在创建等式右侧对象的一个引用。

将对像以参数的形式传入函数时，其实只是传入了一个引用，不会发生任何复制。

动态引用和强类型

变量只是对象的在特定命名空间中的名称，没有与之关联的类型信息。

函数type可以查看某个示例的对象名称

>>> a = 1

>>> type(a)

<class 'int'>

>>>

函数isinstance可以用来检查一个对象是否是某个特点类型的实例。

>>> a = 1;b = [1,2]

>>> isinstance(a,(list,dict))

False

>>> isinstance(b,(list,dict))

True

>>>

引入模块：

模块是一个含有函数和变量定义.py文件。

有下面三种写法：

Import 模块名
Form 模块名 import 变量1,函数1
Import 模块名 as 别名

当需要指定模块路径时可以参考：

import sys
sys.path.append("C:/Program Files/Tinysoft/Analyse.NET")

二元运算符is

要判断两个引用是否指向同一个对象可以用is，判断不是用is not

>>> a = [1,2,3]

>>> b = [1,2,3]

>>> id(a)#内存地址

2108987722376

>>> id(b)

2108987798984

>>> a is b

False

>>> a==b

True

>>> a=b

>>> a is b

True

>>>

可变和不可变的对象：

大部分python对象是可变的，比如列表、字典、numpy以及大部分用户自定义类型。即它们所包含的对象或值是可以被修改的。

而字符串、元组等则是不可变的，也就是说即使修改成功也是创建了一个新对象并将引用赋值给原变量。

hasattr() getattr() setattr() 函数使用方法：

hasattr(object, name:string):bool	判断一个对象里面是否有name属性或者name方法
getattr(object, name:string[,default])	获取对象object的属性或者方法。
setattr(object, name:string, values)	给对象的属性赋值，自定义对象的属性不存在时，先创建再赋值。

字符串：

• 字符串常量可以用单引号或者双引号。
• 带有换行符的多行字符串可以使用三重引号
• 字符串是不可变的。
• Python对象可以用str函数转换为字符串。
• 字符串最左边引号加r，表示所有字符按照原本的样子解释。

  >>> b = 'kljk\nk'

  >>> print(b)

  kljk

  k

  >>> b = r'kljk\nk'

  >>> print(b)

  kljk\nk

  >>>

控制流：

If,while范例：

import numpy as np
#20 次考试的成绩
rdata = list( np.random.randn(20)*25 + 60 )
 
#计算 及格的次数以及及格的时候的平均分
s = 0
times = 0
for v in rdata:
if v<60:
continue
times += 1 #次数加1
s += v #计入总分
print('及格次数：%d ; 及格平均分：%f' % (times,s/times))
 
 
#计算在第几次实现第三次及格
n = 0
i = 0
while n<3:
if i==len(rdata):
print('未及格3次！')
break
elif rdata[i]>60:
n += 1
i+=1
#这里的else在条件为假时执行，break的时候会跳过
else:
print("在第{0}次考试中实现第三次及格".format(i))

三元表达式：

可以将产生一个值的if-else-块写到一行或一个表达式中。

>>> a = 3

>>> b = 10 if a<5 else 0

>>> b

10

元组

• 创建元组

  >>> tup1 = 1,2,3

  >>> tup1

  (1, 2, 3)

  >>> tup2 = (1,2,'3')

  >>> tup2

  (1, 2, '3')

  >>> tup3 = tuple('123')#任何序列或迭代器都可以转为元组

  >>> tup3

  ('1', '2', '3')

  >>>

• 虽然存储在元祖中的对象本身可能是可变的，但是一旦创建完毕，元组的各个对象不能再被更改。

  >>> b = [1,2,],3

  >>> b

  ([1, 2], 3)

  >>> b[0][1]=2

  >>> b

  ([1, 2], 3)

  >>> b[1]=2

  Traceback (most recent call last):

  File "<pyshell#122>", line 1, in <module>

  b[1]=2

  TypeError: 'tuple' object does not support item assignment

  >>>

• 元组可以通过加号（+）运算符连接起来以产生更长的元祖。
• 跟列表一样，对一个元组乘以一个整数，相当于连接该元组的多个副本。

元组拆包

• 对元组类型变量表达式进行赋值，python就会尝试将等号右侧的值进行拆包。

  >>> tup = 1,2,3,4

  >>> a,b,c,d = tup

  >>> a

  1

  >>> d

  4

• 即使是嵌套元祖也能拆包。

  >>> tup = 1,2,(4,5)

  >>> a,b,(c,d)=tup

  >>> d

  5

列表

• 列表是变长的，其内容也是可以修改的。
• 可以通过方括号或list进行创建。

  >>> vlist

  ['1', '2', '3']

• 通过append方法在末尾添加元素

  >>> vlist.append(10)

  >>> vlist

  ['1', '2', '3', 10]

• 通过insert方法在指定位置插入

  >>> vlist.insert(2,'g')

  >>> vlist

  ['1', '2', 'g', '3', 10]

• Pop方法可以删除指定位置的元素，默认删除结尾的元素

  >>> vlist.pop(2)

  'g'

  >>> vlist

  ['1', '2', '3', 10]

  >>> vlist.pop()

  10

• Remove方法按值删除元素，找到第一个符合要求的值并删除。

  >>> vlist = ['1', '2', '3', 10]

  >>> vlist.append('3')

  >>> vlist

  ['1', '2', '3', 10, '3']

  >>> vlist.remove('3')

  >>> vlist

  ['1', '2', 10, '3']

• 通过in关键字可以判断列表是否含有某个值。

  >>> 10 in vlist

  True

  >>>

合并列表

• 可以通过加号（+）运算符连接起来以产生更长的列表。
• 对一个列表乘以一个整数，相当于连接该列表的多个副本。
• 对于一个已定义的列表通过extend方法实现"+="一样的效果。比单纯的加号运算节省资源。

  *加号运算产生新的对象

  >>> a = list(range(10))

  >>> id(a)

  2275607487752

  >>> a = a + a

  >>> id(a)

  2275607488136

  >>> a

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

  *extend对象未产生新对象

  >>> a = list(range(10))

  >>> id(a)

  2275607428168

  >>> a.extend(a)

  >>> id(a)

  2275607428168

  >>> a

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

  >>>

  *+=未产生新对象

  >>> a = list(range(10))

  >>> id(a)

  2275607488200

  >>> a+=a

  >>> id(a)

  2275607488200

  >>> a

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

列表排序方法sort

调用列表的sort方法可以实现就地排序，无需创建新对象。

Sort的key可以指定一个产生用于排序的值的函数。

>>> a = ['abc','g','g2','gg']

>>> a

['abc', 'g', 'g2', 'gg']

>>> a.sort()

>>> a

['abc', 'g', 'g2', 'gg']

>>> a.sort(key=len)

>>> a

['g', 'g2', 'gg', 'abc']

>>>

二分搜索及维护有序列表

• 内置的bisect模块实现了二分查找及对有序列表的插入操作。
• 模块的函数bisect可以找出新元素应被插入到哪个位置才能保持原列表的有序性。
• 函数insort则将新元素插入并保持原列表的有序性。

  >>> import bisect

  >>> c = [1 2,2,5]

  >>> bisect.bisect(c,9)

  4

  >>> bisect.bisect(c,2)

  3

  >>> c

  [1, 2, 2, 5]

  >>> bisect.insort(c,2)

  >>> c

  [1, 2, 2, 2, 5]

  >>>

内置的序列函数

跟踪当前项的索引enumerate

可以逐个返回序列的（index,value）元组

>>> a = list('abcd')

>>> for index,value in enumerate(a):print('a[{0}]="{1}"'.format(index,value))

 

a[0]="a"

a[1]="b"

a[2]="c"

a[3]="d"

>>>

从序列得到有序列表Sorted

将任何序列返回为一个新的有序列表。

将多个序列的元素配对zip

• Zip用于将多个序列中元素配对。最终得到的元组数由最短的序列决定。

比如要求seq1,seq2,seq3对应位置的数字之和

>>> seq1 = [1,3,5]

>>> seq2 = [2,8,10]

>>> seq3 = [4,9,11]

>>> for a,b,c in zip(seq1,seq2,seq3):print(a+b+c)

 

7

20

26

也可以结合enumerate一起使用。

>>> for index,(a,b,c) in enumerate(zip(seq1,seq2,seq3)):print(index,a+b+c)

 

0 7

1 20

2 26

>>>

• 对于已压缩的序列，zip还可以对序列进行解压，相当于取二维数组的列。

>>> g = [[1,2],[20,3]]

>>> h,c = zip(*g)

>>> h

(1, 20)

>>> c

(2, 3)

>>>

逆序reversed

返回可以按逆序迭代序列中的元素的迭代器。

>>> g = [1,2,3,23]

>>> reversed(g)

<list_reverseiterator object at 0x000001BF5A611AC8>

>>> list(reversed(g))

[23, 3, 2, 1]

>>>