python基础

注释快捷键

　　ctrl +   (注释与取消注释）

转义

　　使用 r " " 代表 " " 中的不转义，

print('\	\byy')
print(r'\	\byy')

>>>   yy
>>>\	\byy

　　对于参数为路径的，为什么要带r‘’， 因为，路径中有“",  ""为转义符，带上r”“，代表不转义，否则会报错

path3 = os.path.dirname(r'C:Usersviruser.v-desktopPycharmProjectshexinpracticepickle.txt')

sep

end

　　print（）的参数，sep：值与值得分隔符，默认为空格；  end：以什么结尾

　　print（）默认在字符串末尾增加换行符结尾，对于输出后不想换行时，可增加：end = “”

字符串

　 编码

　　　　ascii  ： 一个字节

　　　　unicode： 通常为2个字节，

　　　　utf - 8 ：可变长编码，字母等为一个字节，汉字通常为三个字节，生僻字等为四-六个字节

 　　在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码

　　s.encode:  编码

print(b'xe4xb8xadxff'.decode('utf-8', errors='ignore'))   # 忽略编码中无法被编码部分

　　s.decode：解码

　　len（s） ： 字符串长度

 内置数据类型

　　list 、  tuper、  dict 、  set

　　list： 有序可变列表，可随时添加和删除元素　　

　　　　创建list： L1 = [1, 2, 3]

　　　　使用索引访问list，当索引超出范围时，提示indexError

　　tuper：有序列表，初始化后不可变

　　　　创建tuper： t1 = （1，2，3）， 定义tuper只有一个元素时，必须加一个逗号，t = （1，） （用以和数学中t =（1）区分，数学中该括号为小括号，不为元组）

　　dict：使用键-值存储（键不重复），具有极快的查找速度（也成为map），可添加和删除键值

　　　　当字典中key不存在时，报错提示 “key error”

　　　　判断key是否存在方法：

　　　　 “key” in dict

　　　　 dict.get（‘key’）

　　dict中的key为不可变对象（需要通过key计算位置（哈希算法));

　　不可变对象：字符串、整数等均可作为key，list为可变对象不能作为key

dict  = {"yuyu":12, "hahau":13}
dict['bubu'] = 34
print(dict)
print('yuyu' in dict)    # 使用in判断key是否存在，结果为true/false
print(dict.get("bubu"))   # 使用get判断key是否存在，不存在时返回None
key = [1,2,3]
dict[key]  = 'lala'   #  使用列表作为可以，报错提示typeError
print(dict)


>>>
{'yuyu': 12, 'hahau': 13, 'bubu': 34}
True
34
Traceback (most recent call last):
  File "C:/Users/viruser.v-desktop/PycharmProjects/hexin/practice/practice.py", line 115, in <module>
    dict[key]  = 'lala'
TypeError: unhashable type: 'list'

　set ： 集合，无重复元素

　　　　创建set： s = set（[1，2，3]）

　　　　重复元素在set中会自动被过滤

s1 = set([1,2,3])
s2 = set([1,4,5,6,2])
s1.add(2)  #  在集合中增加重复元素会被自动过滤掉
print(s1)
print(s1 & s2)  # 交集
print(s1 | s2)  # 并集

>>>
set([1, 2, 3])
set([1, 2])
set([1, 2, 3, 4, 5, 6])

　　内置数据类型小结：

　　tuple：不可变列表，代码更安全，需要对列表防止修改时，可使用tuple代替list

　　list：随着元素增加查找和插入的时间增加；占用空间小

　　dict：查找和插入速度极快，不会随着key是增加而变慢； 但需要占用大量内存

 　  set ：与dict的唯一区别为没有存储对应的value，与dict一样不可放入可变元素（无法判断两个元素是否相等）

　　可变对象与不可变对象：

　　可变对象：list，dict，set等，对该变量操作后，对象值发生变化

　　不可变对象：str，对str变量操作后，实际是创建了新的变量，原变量内容不变

　　

L1 = [1,2,3]
L1.append(4)
a = 'abc'
b = a.replace('a', 'A')  # replace替换a字符串中值,a指向的对象不变,使b指向创建的新对象'Abc'
print("L1的值为:{0}
a的值为:{1}
b的值为:{2}".format(L1, a, b))  

>>>
L1的值为:[1, 2, 3, 4]
a的值为:abc
b的值为:Abc

函数

　　内置函数：

　　　　http://docs.python.org/3/library/functions.html   （可查看内置函数有哪些，及内置函数的用途）

　　　　调用函数时，参数数量错误/参数类型错误均会报错：typeError，（具体错误原因查看错误信息）

print(hex(25print(hex(255))  #将255转换为16进制5))  

>>> oxff

　　　　

　　　　参数类型检查  ：使用内置函数：isinstance()

def my_abs(x): 
    if x >= 0:
        return x
    else:
        return -x

print(my_abs('a'))

>>> a

#  上述my_abs 的定义未对参数类型进行检查，应添加定义只允许整数和浮点数类型的参数
def my_abs(x):
    if not isinstance(x, (int, float)):
        raise TypeError('bad operand type for my_abs():{0}'.format(type(x)))
    if x >= 0:
        return x
    else:
        return -x

print(my_abs('a'))

>>>
Traceback (most recent call last):
  File "C:/Users/viruser.v-desktop/PycharmProjects/hexin/practice/practice.py", line 129, in <module>
    print(my_abs('a'))
  File "C:/Users/viruser.v-desktop/PycharmProjects/hexin/practice/practice.py", line 123, in my_abs
    raise TypeError('bad operand type for my_abs():{0}'.format(type(x)))
TypeError: bad operand type for my_abs():<type 'str'>

　　函数参数

　　　　位置参数：调用函数，按位置输入参数，例power（x），x就为位置参数

def power(x):   #  计算x2
    return x * x

　　　　

　　　　默认参数： （默认参数降低调用函数的难度，对于有多个参数，其中几个参数基本不变时可采用默认参数）

def power(x,n=2):  # 默认求x2,求xn时,需输入n对应的值
    s = 1
    while n>0:
        n = n -1
        s = s*x
    return s

　　　　　　默认参数必须指向不可变对象

def add_end(L=[]):   # 可修改 L = None
    L.append('end')
    return L

print(add_end([1,2,3]))
print(add_end(['x','y']))
print(add_end())
print(add_end())  # 当默认参数为可变时，定义是，L=[],首次调用时 L=['end']即L的值被改变，,即每次调用时，默认参数的值会被改变，不再是[]

>>> [1, 2, 3, 'end'] ['x', 'y', 'end'] ['end'] ['end', 'end']

　　　　可变参数：可变参数允许传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple

　　　　　　　　　当参数已经是一个list或者tuple时，可将该list/tuper直接作为可变参数传入

def calc(*numbers):  # 求 a2 + b2 + c2.....
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum


print(calc())
print(calc(5, 6, 7))
num = [1, 2, 3, 5, 7, 8, 9]
print(calc(*num))  # 将该list/tuper直接作为可变参数传入

　　　　

　　　　关键字参数：允许传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict

def person(name, age, **kw):
    print('name:{0};age:{1};other:{2}' .format(name, age, kw))

person("雨雨", 23, city = 'bj',score = '100')

#  在python2以ascii编码，因此不能直接print（name，age），print（name，age）返回为一个元组，而name为汉字，age为数字，，统一使用ascii编码时汉字会乱码。

　　　　　　命名关键字参数  ：限制关键字参数的名字

def person(name, age, *, city, job):
    print(name, age, city, job)

>>> person('Jack', 24, city='Beijing', job='Engineer')

Jack 24 Beijing Engineer

>>>kw = {'city':'bj', 'score':'100'}  
person("雨雨", 23, **kw)

　　递归函数

# coding=utf-8
"""
  删除列表中相邻重复元素,例,当abbac,删除重复元素bb后,为aac,继续删除aa
"""
def transfer (s):
    m = len(s)
    for i in range(1, m):
        if s[i] == s[i-1]:
            s.remove(s[i])
            s.remove(s[i-1])
            return transfer(s)   # 此处必须使用return 代表外层函数的结束,若无return代表调用函数执行完继续执行外层函数
    print(s)

s = ['a','b','b','a','c','a']
transfer(s)

python 特性

　　切片：切片可应用于list、tuper、字符串　　　　

l = [1,2,3,4]
print(l[x:y:z])   #x默认为0，y默认为最后一个，z默认为1  

　　迭代：迭代可应用于list、tuper、字典、字符串等可迭代对象上

　　判断对象是否可迭代 ？

list = [1,2,3,4,5]
dict = {'a':1, 'b':2, 'c':3}
char = ('ABC')

for L in list:
    print(L)
for i, L in enumerate(list):  # 同时迭代list中的索引和值
    print(i, L)

for key in dict:   # 迭代字典中的key
    print(key)
for value in dict.values():  # 迭代字典中的value
    print(value)
for key, value in dict.items():  # 同时迭代字典中的key和value
    print(key,value)

for ch in char:
    print(ch)

　　列表生成式 ：创建list的生成式

# 生成list:1,2,3,4,5,6....
L1 = list(range(1,22))

#  生成[1*1,2*2,3*3...]
L2 = [x * x for x in range(1,11)]

# 生成[2*2, 4*4, 6*6..]等偶数的平方
L3 = [x * x for x in range(1,11) if x % 2 == 0]

# 列出当前目录下多有文件和目录名
import os
L4 = [d for d in os.listdir('.')]

# 使用两个变量生成列表
d = {'x': 'A', 'y': 'B', 'z': 'C' }
L5 = [m + '=' + n for m, n in d.items()]

# 把list中所有字符串变成小写
L = ['Hello', 'World', 'IBM', 'Apple']
L6 = [s.lower() for s in L]

# 将列表中所有大写字母变为小写,其余不变
Ln = ['Hello', 'World', 18, 'Apple', None]
L7 = [s.lower() if isinstance(s,str) else s for s in Ln ]

　　

　　生成器：当列表元素可通过某种算法推算出来时，可在循环过程中不断推算出后续的元素

定义生成器的两种方法：

第一种：将列表生成式中的【】变为（）

g = (x * x for x in range(10))  # 将列表生成式中的[]变成（）该g为一个生成器

# print(g.next())  # 需要获取列表的下一个数据时，不断获取g.next()

''' for n in g:    # 可通过循环输出所有列表元素
        print(n)
'''
for n in range(0,5):   #也可设定输出区间内的列表元素
    print(g.next())

第二种：yield  ：遇到yield时返回，下次执行从上次返回的yield语句出继续执行

# 斐波拉契数列
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
'''
 m = fib(10)   # 创建一个generator的对象,然后不断调用next获取下一个返回值
 print(next(m))
'''
for n in fib(10): # 使用循环不断调用yield
    print(n)

例：杨辉三角

'''杨辉三角'''
def triangles():
    L = [1]
    while True:
        yield(L)
        L.append(0)
        L = [L[i]+L[i-1] for i in range(len(L))]
        
m = triangles()
for t in range(10):
    print(m.next())

　　迭代器：可以被next（）函数调用并不断返回下一个值得对象成为迭代器 :  Iterator

　　凡是可以作用于for的为可迭代对象:Iterable，如list、dict、str； 但可以通过iter（）函数获得一个Iterrator对象

m = [1,2,3] # Iterable
L = [x for x in range(10)]  # Iterator

M = iter(m)  
print(M.next())