Python自学笔记1

1.注释

#单行注释

'''
多行注释
多行注释
'''

"""
多行注释
多行注释

"""

2.基本运算

print(1/3)#除法
print(11//2)#// 运算符执行古怪的整数除法。如果结果为正数，向小取整，比如结果为5.取整后为5，如果为-5.5取整后为-6
           #运算符并非总是返回整数结果。如果分子或者分母是float，它仍将朝着最近的整数进行四舍五入，但实际返回的值将会是 float 类型

print(11**2)#** 运算符的意思是“计算幂”， 112 结果为 121
print(11%2) #取余数

分数：

import fractions

x = fractions.Fraction(1,3)#分数

print(x)#输出1/3
print(fractions.Fraction(2,6))#自动约分，输出1/3

三角函数：

import math

print(math.pi)#输出3.141592653589793

print(math.sin(math.pi / 2))#输出1.0

print(math.sin(math.pi / 6))# 求30度的正弦值，输出0.49999999999999994

常用函数：

print(math.floor(2.3))#返回不大于x的整数,输出2
print(math.fabs(-5))#绝对值，输出5.0
print(math.ceil(3.5))#返回大于参数x的最小整数,即对浮点数向上取整,输出4
print(math.hypot(3,4))#返回以x和y为直角边的斜边长,输出5
print(math.copysign(3,4))#若y<0，返回-1乘以x的绝对值；否则，返回x的绝对值,输出3
print(math.frexp(3))#返回m和i，满足m乘以2的i次方==x,输出(0.75, 2)
print(math.degrees(math.pi))#弧度转度,输出180.0
print(math.radians(180))#度转弧度,输出3.141592653589793

---

3.类型转换

print(int(1.0))#float转为float，输出1
print(float(1))#float转为int，输出1.0
print(int(2.1))#取整，输出2，注意不是四舍五入

---

4.条件语句

if 语句

if 0:#在布尔类型上下文环境中，非零整数为真；零为假
    print(1)
else:#else 与 if 对齐
    print(0)

---

5集合

列表

list = [1,2,3,4,5,6]
print(list)#输出[1, 2, 3, 4, 5, 6]

#整形中混合浮点型
list = [1,2,3,4,5,5.8]
print(list)#输出[1, 2, 3, 4, 5, 5.8]


list = ["a","b","c","d"]
print(list)#输出['a', 'b', 'c', 'd']

#字符中混合整形
list = ["a","b","c","d",2]
print(list)# 输出['a', 'b', 'c', 'd', 2]

列表切片：

#字符中混合整形
list = ["a","b","c","d",2]
print(list)# 输出['a', 'b', 'c', 'd', 2]
print(list[0:3])#截取0到3的元素，输出['a', 'b', 'c']
print(list[:3])#截取0到3的元素，输出['a', 'b', 'c']
print(list[-1:3])#输出[]
print(list[3:])#输出['d', 2]

添加数据：

list = ["a","b","c","d"]
list.append("s")#尾部添加一个元素
print(list)#输出['a', 'b', 'c', 'd', 's']
list.append(["e","f","g"])#将集合作为一个元素添加到尾部，
print(list)#输出['a', 'b', 'c', 'd', 's', ['e', 'f', 'g']]
list.insert(2,"3")#插入第二个位置
print(list)#输出['a', 'b', '3', 'c', 'd', 's', ['e', 'f', 'g']]
list.extend(["e","f","g"])#添加集合的所有元素到尾部
print(list)#输出['a', 'b', '3', 'c', 'd', 's', ['e', 'f', 'g'], 'e', 'f', 'g']

元组

其实相当于java中的数组。

s = (1,2,3,4,5)
print(s)#输出(1, 2, 3, 4, 5)
print(s[0])#输出1
print(s[0:3])#输出(1, 2, 3)

集合

set = {"a","b","c","d","e"}
print(set)#输出{'a', 'c', 'b', 'e', 'd'}
print(len(set))#集合长度，输出5
set.add("1")#添加元素到随机位置
print(set)#输出{'1', 'a', 'd', 'e', 'c', 'b'}
set.update({2,3,4})#添加集合的所有元素
print(set)#输出{2, 3, 4, '1', 'c', 'b', 'a', 'e', 'd'}
set.update([5,6])#添加列表的所有元素
print(set)#输出{2, 3, 4, 5, 6, 'd', 'a', 'e', 'b', '1', 'c'}
set.update((7,8))#添加元组的所有元素
print(set)#输出{'e', 2, 'c', '1', 3, 4, 5, 'b', 6, 7, 8, 'd', 'a'}
print(set.__contains__(7))#判断元素是否存在，输出True
bset = {7,8,9}
print(bset.difference(set))#创建新的集合，返回bset有而set没有的元素，输出{9}
print(bset.union(set))#创建新的集合，返回set与bset的元素，就是并集，输出{2, 3, 4, 5, 6,
# 7, 8, 9, 'b', 'e', '1', 'a', 'c', 'd'}
print(bset.intersection(set))#输出交集，{8, 7}
set.discard(7)#删除元素7
print(set)#输出{'d', 'a', 2, 3, 'c', 4, 5, 6, 8, 'b', 'e', '1'}
set.remove(8)#删除元素8
print(set)#输出{2, 3, 4, 5, 6, 'd', 'e', 'c', 'b', '1', 'a'}
set.pop()#出栈
print(set)#输出{2, 3, 'd', 4, 5, 6, 'a', '1', 'b', 'e'}

字典

dis = {'1':'a','2':'b'}
print(dis)#输出{'1': 'a', '2': 'b'}
print(dis['1'])#读取，输出a
dis['1'] = 'c'#修改
print(dis)#输出'1': 'c', '2': 'b'}

None

1.与任何值比较都是false
2.布尔型环境中为假，非None为真

6.字符串

#字符串更新
b  ="Line1-abcdef-abcLfine4-abcd"
bs = b.split('f',1)#指定分割符号f,分割一次
print(bs)#['Line1-abcde', '-abcLfine4-abcd']
bs = b.split('f',2)#指定分割符号f,分割两次
print(bs)#['Line1-abcde', '-abcL', 'ine4-abcd']

import  re
print(re.split('a',b))#指定分割,分割多次，输出['Line1-', 'bcdef-', 'bcLfine4-', 'bcd']

#字符串更新
var1 = 'Hello World!'
print("更新字符串 :- ", var1[:6] + 'Runoob!')#输出更新字符串 :-  Hello Runoob!

#字符串与字节的相互转化
s1='公共媒体gg'
bs = s1.encode('gbk')
print(bs)#b'\xb9\xab\xb9\xb2\xc3\xbd\xcc\xe5gg'
print(type(bs))#
print(bs.decode('gbk'))#公共媒体gg

Python转义字符

在需要在字符中使用特殊字符时，python用反斜杠()转义字符。如下表：
转义字符 描述
(在行尾时) 续行符
\ 反斜杠符号
\’ 单引号
\” 双引号
\a 响铃
\b 退格(Backspace)
\e 转义
\000 空
\n 换行
\v 纵向制表符
\t 横向制表符
\r 回车
\f 换页
\oyy 八进制数，yy代表的字符，例如：\o12代表换行
\xyy 十六进制数，yy代表的字符，例如：\x0a代表换行
\other 其它的字符以普通格式输出

python的运算符号

+：字符串拼接

s1 = 'abc'
print(s1+'cdef')#output:abccdef

*重复输出

s1 = 'abc'
print(s1*3)#abcabcabc

[]通过索引输出字符串或者字符

s1 = 'abcdef'
print(s1[2])#c
print(s1[0:3])#abc
print(s1[:4])#abcd

in 判断是否存在字符串

s1 = 'abcdef'
print('a' in s1)#True
print('a' not in s1)#false

r输出原始字符，就是不转义

s1 = r'\n2344\\\r'
print(s1)#\n2344\\\r

%格式化字符串

print("He is %d years old"%(25))#He is 25 years old
print("His height is %.2f m"%(1.83))#His height is 1.83 m

---

7.循环

while循环

s = [1,2,3,4,5,6,7]

sum = 0
i = 0

while sum<20:
    sum = sum+s[i]
    i+=1

print(i)

for循环

s = [1,2,3,4,5,6,7]

sum = 0
for a in s:
    sum+=a

print(sum)#28

pass语句
Python pass是空语句，是为了保持程序结构的完整性。
pass 不做任何事情，一般用做占位语句

s = [1,2,3,4,5,6,7]

sum = 0
for a in s:
    if a%2==0:
        pass
    else:
         sum+=a

print(sum)#16

8.时间获取

获取本地时间

import time

times = time.localtime()
print(times)#time.struct_time(tm_year=2017, 
# tm_mon=5, tm_mday=25, tm_hour=15, tm_min=41, 
# tm_sec=19, tm_wday=3, tm_yday=145, tm_isdst=0)

for t in times:
    print(t)

#输出 
'''
25
15
41
19
3
145
0
'''

格式化时间

import time

times = time.time()#获取时间戳
print(times)#1495698201.417115

#时间格式化
print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))#2017-05-25 15:45:29

%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称

---

9.函数定义

def声明，注意python的变量是没有声明类型而已

def method1(s):
    return "sucess"#不写返回值默认返回none

print(method1('3'))#sucess

参数传递：

不可变类型：如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型：如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

缺省参数：
如果该参数不传递，会传递默认值

#缺省参数b,不传递，默认为test
def method1(s,b='test'):
    print(s)
    print(b)

method1([1,2,3,4,5])#sucess

不定长参数
不限定传入参数个数，用*声明

#不定长参数b不传递，默认为test
def method1(s,*b):
    print(s)
    for i in b:
        print(i)

method1('s',[1,2,3,4,5],[4,5,6,7,8])#sucess

输出如下：
s
[1, 2, 3, 4, 5]
[4, 5, 6, 7, 8]

匿名函数

用lambda 声明

sum = lambda a,b:a+b
print(sum(1,2))#输出3

---

10.模块引入

1.引入模块：

import module1[, module2[,… moduleN]

2.引入模块的指定部分：

from modname import name。

引人全部：from modname import *

---

11.下划线权限说明

_foo_: 定义的是特列方法，类似 init() 之类的。
_foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *
__foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了

---

12.创建类

class Test1:

 a =1

 def __init__(self, __private_var1):#__init__有点想java的构造器
     self.a = __private_var1

class B(Test1):#()是继承，支持多继承，Class1（class2,class3...）
    def __init__(self):
        self.a = 5

b = B()
print(b.a)#输出5

---

13.异常捕捉

try:
    pass#code
except IOError:
   pass#do when error happened
else:
    pass#no error happened

---

14.使用正则表达式功能

import  re

re.match(pattern, string, flags=0)
re.search(pattern, string, flags=0)