teststr="hello ,world!"

outstr=teststr[1:4]
outstr2=teststr[-7:-5]
outstr3=teststr[4:-1]
outstr4=teststr[::3] #每隔3个
outstr5=teststr[:] #直接复制
print(outstr,'|',outstr2,'|',outstr3,'|',outstr4,'|',outstr5)
#ell | ,w | o ,world | hl,r! | hello ,world!

a="hello"
b="wrold"
print (a+" "+b)  #序列加

if 'h' in a:
    print("h in "+a )  # in
else:
    print("h not in "+a )

print("max is "+max(a)) #max is o
print("min is "+min(a)) #min is e
print(list(a))  #list ['h', 'e', 'l', 'l', 'o']

列表赋值

list方法返回列表

#列表赋值------------------
a=list("hello")
del a[1:2] #删除
print(a)  #['h', 'l', 'l', 'o']

#分片赋值
a[1:1]=list("test")
print(a) #['h', 't', 'e', 's', 't', 'l', 'l', 'o']
a[1:5]="-" #['h', '-', 'l', 'l', 'o']
print(a)
#-----------------------------

列表方法

append() , extend, index, insert, pop,remove,reverse ,sort

#列表方法-------------------
#append() , extend, index, insert, pop,remove,reverse ,sort
#---------------------------
a.append("ad")
print(a)
print(a.count("l")) #2  count() 计数
b=a.extend(list("ac"))  #扩展原列表，返回空
print(b) #None
b=a[:] #copy
print(b)
print(b.index('h')) #0
a.insert(2,"22") # ['h', '-', '22', 'l', 'l', 'o', 'ad', 'a', 'c']
print(a)
print(a.pop(1))  # - 返回值， 默认最后一个
print(a)
a.remove("ad") #匹配第一个，删除，无返回
a.sort()
print(a) #['22', 'a', 'c', 'h', 'l', 'l', 'o']

sort 特殊排序

a=["abc","a123","123","a","1"]
#a=["a","1"]
b=a[:]
c=a[:]
def mysort(inputval):  
    lt=list(inputval[1:3])
    if(len(lt)>1):
        return max(lt)
    elif(len(lt)>0):
        return lt[0]
    else:
        return "-1"

a.sort(key=mysort)
b.sort(key=len)
c.sort()
print(a)  #['a', '1', 'a123', '123', 'abc']
print(b) #['a', '1', 'abc', '123', 'a123']
print(c) #['1', '123', 'a', 'a123', 'abc']

列表推导

【x for 。。。】  利用已有列表直接生成新的列表。推到。

(x for。。。)  生成器。生成的为算法。使用next(generator) 或者 循环取值。

a=[x*x for x in range(0,4)]
print(a)
a=[(x,y) for x in range(1,4) for y in range(2,4)]
print(a)  #[(1, 2), (1, 3), (2, 2), (2, 3), (3, 2), (3, 3)]

b=((x,y) for x in range(1,4) for y in range(2,4))
c=next(b)  # generator 计算下一个值
for item in b:    #直接循环
    print(item)
#(1, 3)
#(2, 2)
#(2, 3)
#(3, 2)
#(3, 3)

字符串

字符串print对齐

兴冲冲的看了个左对齐，发现对汉字无效。。。

然后又在java中试了一遍，一样的问题。∑( ° △ °|||)︴，果然基础不扎实

p_format="%-*s%*.2f"
head_format="%-*s%*s"
leftwidth=45
pricewidth=10
print("价格表")
print('='*(leftwidth+pricewidth))
print(head_format % (leftwidth,"水果",pricewidth,"价格"))
print(head_format % (leftwidth,"Items",pricewidth,"price"))
print('-'*(leftwidth+pricewidth))

print(p_format % (leftwidth,"pear",pricewidth,28.1))
print(p_format % (leftwidth,"apple",pricewidth,28.12312))
print(p_format % (leftwidth,"苹果杀杀杀啊",pricewidth,34.1123))
print(p_format % (leftwidth,"超级水水果",pricewidth,134.3))
print(p_format % (leftwidth,"adasdfsdf",pricewidth,34.1123))
print(p_format % (leftwidth,"苹果",pricewidth,34.1123))

print('%-*sa%*s'%(30,'hi',15,'world'))
print('%-*sa%*s'%(30,'aavbvvvvv',15,'world'))


价格表
=======================================================
水果                                                   价格
Items                                             price
-------------------------------------------------------
pear                                              28.10
apple                                             28.12
苹果杀杀杀啊                                            34.11
超级水水果                                            134.30

高阶函数

函数式编程，基本跟js很像了。

map,reduce,filter，sorted 分别给列表中的数据执行一遍函数，$.each(function,xxxx)...(╯°Д°)╯

def r2(x):
    return x*x

y=map(r2,[1,2,3,4])

print(list(y))

闭包

闭包就是能够读取其他函数内部变量的函数。只有函数内部的子函数才能读取局部变量，所以闭包可以理解成“定义在一个函数内部的函数

能不折腾就不要折腾了，要啥子闭包，程序不就是为了简化生活来的嘛，自己把自己转晕，没意义。。∑( ° △ °|||)︴

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i #局部变量，最后下面调用时，变量已改变
        fs.append(f)
    return fs

f=count()
for fun in f:
    print(fun()) #，9，9，9

print('==============')
def count2():
    fs = []
    def f(i):
        def ff():#ff为闭包，引用的变量在函数外部
            return i*i
        return ff

    for i in range(1, 4):
        fs.append(f(i)) # f实际为内部闭包函数
    return fs

f2=count2()
for fun in f2:
    print(fun())  #1，4，9

Class

class（父类1，父类2），继承，多继承同名方法取第一个父类。后面父类方法被覆盖。

属性访问靠自觉- -！

__attrname ，双下划线，默认不能外部访问， 实际可以使用 _calssname__attrname访问。

_name, 不建议访问内部属性，约定而已。

函数内方法第一个参数默认 self.

__slots__ 限制使用的属性

函数定义，默认参数=号前 接 ：增加任意注释.

__str__

__repr__ 特殊函数说明

@property /@attr.setter  get/set设置

注释防止在定义内部，真诡异(→

logging.引用

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


#coding=utf-8

import logging
logging.basicConfig(level=logging.INFO)


#from copy import  *,只能能使用 __all__里面的方法，
#import copy.    copy.xxxx可以使用其他方法
__all__=[catEat]  

class cat(object): # 继承
    """
    cat ??
    :param age: ageddd
    :return: dd
    """

    animal_type="cat" #类变量，静态
    __slots__=("__age","__name","__sex","otherattr") #限制只能有这些属性

    def __init__(self,age:"ddd注释"=4,name='小平凡',sex='公猫') -> None: #-->返回参数注释
        self.__name=name
        self.__sex=sex
        self.__age=age
        self.otherattr='xxx'  #属性随意，同js,不要太自由
        logging.info("cat created!")# log

    def __str__(self):  #toString().
        return 'cat object (name: %s)' % self.__name
    __repr__=__str__   #调试toString()

    
 
  
    def call(self,master='kxjl'):
        """
        test fun,注释为毛要放到里面？
        """
        print("hi! "+master,', myname is '+self.__name)

    # 获取age
    @property
    def age(self) -> int:   #-->返回参数注释
        return self.__age
    
    # 设置age value
    @age.setter
    def age(self, age):
        if not isinstance(age, int):
            # try except
            try:
                self.__age=2
            except EnvironmentError as err:
                logging.error(err)
            finally:
                pass
          
        if age < 0 or age > 100:
            raise ValueError('age值必须在0=<age<=100')
        self.__age = age



def test():
    c=cat()
    
    print(c.age)
    #c.dd="1"
    print(c.__slots__)
    print(c.animal_type)
    print(cat.animal_type)
    print(dir(c))


if (__name__ == '__main__'):
    test()