Python语言基础

Python是我目前见过的语言中最简洁优雅的，以至于我有一种相见恨晚的感觉。下面是一些笔记（代码）。😃
python

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

__author__='Chiang'

import math
import time
import functools
import logging
logging.basicConfig(level=logging.INFO)

print('hello world!');

print('1','sherlock',3);

print("1+3=",1+3);

#输入输出测试
#name=input("please tell me your name:");
#print("hello,"+name);

#注意条件语句的写法
age=20;
if age>18:
  print("1");
else:
  print('0');


#值的交换
a='1';
b='0';
temp=a;
a=b;
b=temp;
print(a,b);

#常量
PI=3.141592654;
print(PI);


print(ord('A'));

print(len('str'));

print("我爱你！");


#浮点数的表示
#%运算符就是用来格式化字符串的
s1 = 72 
s2 = 85 
r = (s2 - s1)/ s2 * 100
print('%.1f%%' % r)
print('%d' % (1/3))
print('%s' % (1/3))


#Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。
fruits=['apple','orange','lemon'];
print(fruits[-len(fruits)] )
#正向从0开始，负向从1开始
print(fruits[-1])
print(fruits[-2])

fruits.append('apple');
#追加
print('fruits appended:',fruits)
#插入
fruits.insert(0,'juice');
print('inserted fruits:',fruits);
#删除
fruits.pop(1);
print('popped fruits:',fruits);



#循环
for fruit in fruits:
  print(">>",fruit);


L = [
    ['Apple', 'Google', 'Microsoft'],
    ['Java', 'Python', 'Ruby', 'PHP'],
    ['Adam', 'Bart', 'Lisa']
]
print(L[0][0],L[1][1],L[2][2])

final=(1,2,3,4,5);
print(final);

#条件语句
BMI=55/(1.78*1.78);
if BMI>32:
  print('exacly fat');
elif BMI>=28:
  print('fat');
elif BMI>=25:
  print('heavy');
elif BMI>=18.5:
  print('middle');
else:
  print('slin');


#高斯求和
sum=0;
#range(n) 0-> n 但不包括n
for num in range(101):
    sum+=num;
print(sum);
 

#Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，
#使用键-值（key-value）存储，具有极快的查找速度。
score = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
print(score['Bob'])


#要避免key不存在的错误，有两种办法，一是通过in判断key否存在：
#二是通过dict提供的get方法，如果key不存在，可以返回None，或者自己指定的value：
rs='a' in score;
#False
print(rs);
# none
print(score.get('a')) 

#要删除一个key，用pop(key)方法，对应的value也会从dict中删除：
score.pop('Bob');
print(score);

#set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
s=set([1,2,3,4,4,5,5,5,6,6,6,6,6,6]);
print(s);

#通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果：

#通过remove(key)方法可以删除元素：

#set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：

s1=set([1,2,3,4]);
s2=set([3,4,5,6]);
#求交集
print(s1 & s2);



#函数
print(abs(2-3))
print(max(1,2,3,100))
print(min(0,1))
print(str(123))
print(int('123'))
print(float('12.3455'))
m=9
n=10
for x in [m,n]:
  print('%s的十六进制的字符串是' %x,hex(x))


#在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。

def myabs(x):
  #数据类型检查可以用内置函数isinstance()实现：
  if not  isinstance(x,(int,float)):
    raise TypeError(' bad operand type ')
  if x>0:
    return x
  else:
    return -x
print(myabs(-1))
#print(myabs('a'))


def move( x , y , step , angle ):
  newX=x+step*math.cos(angle)
  newY=y+step*math.sin(angle)
  return newX,newY
#Python的函数返回多值其实就是返回一个tuple
print(move(1,1,4,math.pi/6))


def power(x,n=2):
  s=1
  while n>0:
    n=n-1;
    s=s*x;
  return s;

def quadratic(a,b,c):
  flag=power(b)-4*a*c
  rs1=0
  rs2=0
  if flag < 0:
    return '无解'
  elif flag==0:
    rs1=(-b+math.sqrt(power(b)-4*a*c))/2*a
    rs2=(-b-math.sqrt(power(b)-4*a*c))/2*a
    return  rs1
  else:
    rs1=(-b+math.sqrt(power(2)-4*a*c))/2*a
    rs2=(-b-math.sqrt(power(2)-4*a*c))/2*a
    return rs1,rs2

print(quadratic(1,2,1));

print(power(2,10))

#a2 + b2 + c2 + ……
#可变参数就是传入的参数个数是可变的
def  calc(*nums):
  s=0
  for num in nums:
    s=s+power(num)
  return s;
print(calc(1,2,3));


#对于任意函数,都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的
def person(name,age,**kw):
  print('name:',name,'age:',age,'other:',kw)
person('sherlock','32')
person('sherlock','32',address='Baker Street 221B')


def loop(max,n=1):
  if max==1:
    return n;
  else:
    return loop(max-1,max*n);

print(loop(100))



#切片（Slice）操作符，能大大简化这种操作
arr=[1,2,3,4,5]
print(arr[0:3])
#起始位置是0可省略
print(arr[:3])
#step步长
print(arr[::2])

json={'a':'1','b':'2','c':'3'}

#key
for key in json:
  print(key)

#val
for val in json.values():
  print(val)

#item
for k,v in json.items():
  print(k,v)

#带下标的循环
for i, value in enumerate(['A', 'B', 'C']):
  print(i, value)

#2个变量循环
for x,y in [(1,2),(2,3),(3,4)]:
  print(x,y)

#如何判断一个对象是可迭代对象呢？方法是通过collections模块的Iterable类型判断
from collections import Iterable
print(isinstance('abc', Iterable))


#列表生成式

print(list(range(1,11)))

print( [x*x for x in range(1,11)] )

print( [x*x for x in range(1,11) if x%2==0 ] )


Lm = ['Hello', 'World', 18, 'Apple', None]

Ln = [s.lower() for s in Lm if(isinstance(s,str))]

print(Ln)


def  fib(max):
  n,a,b=0,0,1
  while n<max:
    print(b)
    (a,b)=(b,a+b)
    n=n+1
  return 'done'

fib(100)

#要理解generator的工作原理，它是在for循环的过程中不断计算出下一个元素，并在适当的条件结束for循环。对于函数改成的generator来说，遇到return语句或者执行到函数体最后一行语句，就是结束generator的指令，for循环随之结束。

#函数本身也可以赋值给变量，即：变量可以指向函数。


#把函数作为参数传入，这样的函数称为高阶函数，函数式编程就是指这种高度抽象的编程范式。
def add(x,y,f):
  return f(x)+f(y)
print(add(-1,-2,abs))

#map
print( list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])) )

#reduce
from functools import reduce
def  fn(x,y):
  return  x*10+y
print(reduce(fn,[1,2,3,4,5,6]))


def normalize(name):
  return name.capitalize()

L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)



#filter
def isodd(x):
  return  x%2==0
print(list(filter(isodd,[1,2,3])))

#去掉空字符串
def not_empty(s):
    return s and s.strip()
print(list(filter(not_empty,['1','',' ',' ','3'])))


#回文数
def is_palindrome(n):
  return str(n)[::]==str(n)[::-1]
output = filter(is_palindrome, range(1,1000))
print(list(output))

#倒序
print('123'[::-1])

#排序
print(sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower,reverse=True))


scoreList=[('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]

for k in scoreList:
  print(k[0])

def by_name(t):
  return t[0] 

def by_score(t):
  return t[1]

La=sorted(scoreList,key=by_name)
Lb=sorted(scoreList,key=by_score,reverse=True)
print (La)
print (Lb)



#返回函数
def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

f=lazy_sum(1,2,3,4,5,6,7,8,9)
print(f())


#python装饰器，decorator就是一个返回函数的高阶函数


def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper


#获取当前时间

@log
def getCurrentTime():
  return  time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))

print(time.time())

print(getCurrentTime())


#偏函数设定参数的默认值，可以降低函数调用的难度
#int()函数还提供额外的base参数，默认值为10。如果传入base参数，就可以做N进制的转换
def int2(x,base=2):
  return  int(x,base)
print(int2('10000'))


#当函数的参数个数太多，需要简化时，使用functools.partial可以创建一个新的函数，
#这个新函数可以固定住原函数的部分参数，从而在调用时更简单。
int16= functools.partial(int, base=16)
print(int16('16'))


#作用域
#正常的函数和变量名是公开的（public），可以被直接引用，比如：abc，x123，PI等；
#类似__xxx__这样的变量是特殊变量，可以被直接引用
#类似_xxx和__xxx这样的函数或变量就是非公开的（private），不应该被直接引用，比如_abc，__abc等；


#外部不需要引用的函数全部定义成private，只有外部需要引用的函数才定义为public。
def _private_1(name):
    return 'Hello, %s' % name

def _private_2(name):
    return 'Hi, %s' % name

def greeting(name):
    if len(name) > 3:
        return _private_1(name)
    else:
        return _private_2(name)

print(greeting('sherlock !'))


#安装第三方模块: 包管理工具pip
#如果你正在使用Windows，请参考安装Python一节的内容，确保安装时勾选了pip和Add python.exe to Path

# >>>pip install Pillow

#更换py源
# C:\Users\Money\AppData\Local\pip 新建一个pip.ini
# -------------豆瓣-------------------------------
# [global]
# timeout = 6000
# index-url = http://pypi.douban.com/simple
# trusted-host = http://pypi.douban.com
# -------------豆瓣-------------------------------

# -------------阿里云-------------------------------
# [global]
# timeout = 6000
# index-url = http://mirrors.aliyun.com/pypi/simple/ 
# trusted-host=mirrors.aliyun.com
# -------------阿里云-------------------------------
# pypi.tuna.tsinghua.edu.cn 


# -i 指定来源
# pip install web.py -i http://pypi.douban.com/simple

# 常用的第三方库：mysql-connector-python   numpy(科学计算)  


#面向对象：
#类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的
class Student(object):
    #特殊方法“init”前后有两个下划线！！！
  def __init__(self,name,score):
    # self.___name   私有变量，只能访问不能修改
    self.__name=name    
    # self.___score
    self.__score=score

  def get_name(self):
    return self.__name

  def set_name(self,name):
    self.__name=name

  def print_info(self):
    #注意百分号后面的括号
    print('%s: %s' % (self.__name , self.__score) )

  def get_level(self):
    if self.__score>90:
      return 'A'
    if self.__score>80:
      return 'B'
    if self.__score>60:
      return 'C'


#sublime text3:代码区直接全选就会看到有的地方是四个点有个地方是一个横线，改一致了就好了
sherlock=Student('sherlock holmes',100)
sherlock.print_info()
print(sherlock.get_level())

# 在定义class的时候，定义一个特殊的__slots__变量，来限制该class实例能添加的属性
# 
class Animal(object):
  #  __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称
  #  __slots__定义的属性仅对当前类实例起作用，对继承的子类是不起作用的
  def __init__(self,name):
    self.__name=name;
  #默认self必须写上
  def run(self):
    print(self.__name,'i can run')

cat=Animal('cat')
cat.run()

class Dog(Animal):
  def eat(self):
    print('i want to eat bones')

class Cat(Animal):
  def jump(self):
    print('i can jump')

dog=Dog('dog')
dog.run()
dog.eat()

cat=Cat('cat')
cat.jump()


# 获取对象信息:判断对象类型
# 使用type()函数

print(type(123))
print(type(abs))

# type(123)==type(456)      int  True
# type('abc')==type('123')  str  True

# 判断一个对象是否是函数,可以使用types模块中定义的常量

# 使用isinstance()
# isinstance('a', str)     True
# isinstance(123, int)     True
# isinstance(b'a', bytes)  True


# 并且还可以判断一个变量是否是某些类型中的一种，比如下面的代码就可以判断是否是list或者tuple
# isinstance([1, 2, 3], (list, tuple))  True
# isinstance((1, 2, 3), (list, tuple))  True
# hasattr(obj,'name',404)  可以传入一个default参数，如果属性不存在，就返回默认值
# getattr(obj,'name')
# setattr(obj,'name')

# 千万不要把实例属性和类属性使用相同的名字，因为相同名称的实例属性将屏蔽掉类属性
# example 
def readImage(fp):
    if hasattr(fp, 'read'):
        return readData(fp)
    return None


# @property，我们在对实例属性操作的时候，就知道该属性很可能不是直接暴露的
# 而是通过getter和setter方法来实现的
# birth是可读写属性，age就是一个只读属性
class Person(object):

  def __str__(self):
    return 'Student object (birth: %s)' % self._birth

  __repr__ = __str__

  @property
  def birth(self):
    return self._birth

  @birth.setter
  def birth(self, value):
    self._birth = value

  @property
  def age(self):
    return 2017 - self._birth

#如果一个类想被用于for ... in循环，类似list或tuple那样，就必须实现一个__iter__()方法，该方法返回一个迭代对象，
#然后，Python的for循环就会不断调用该迭代对象的__next__()方法拿到循环的下一个值，直到遇到StopIteration错误时退出循环。

class Fib(object):
  def __init__(self):
    self.a, self.b = 0, 1 # 初始化两个计数器a，b

  def __iter__(self):
    return self # 实例本身就是迭代对象，故返回自己

  def __next__(self):
    (self.a, self.b) = (self.b, self.a + self.b) # 计算下一个值
    if self.a > 100000: # 退出循环的条件
      raise StopIteration()
    return self.a # 返回下一个值

for n in Fib():
  print(n)



class Chain(object):

  def __init__(self, path=''):
    self._path = path

  def __getattr__(self, path):
    return Chain('%s/%s' % (self._path, path))

  def __str__(self):
    return self._path

  __repr__ = __str__


#枚举
from enum import Enum, unique

#类似常量
Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))

# @unique装饰器可以帮助我们检查保证没有重复值
@unique
class Week(Enum):
  Sun = 0
  Mon = 1
  Tue = 2
  Wed = 3
  Thu = 4
  Fri = 5
  Sat = 6