python 初体验

Posted 2020-10-10

一.序列类型
   sublime 安装Python交互插件 同cmd


  1.列表[] 元组() 字符串
        列表有序 元祖无序      他们不是真正存储数据，而是存储对象引用
        算术操作符
         +=  -=
  2. 输入
       raw_input()
       input()
  3.定义函数
       dir() id(指内存的对象地址) type() len()
       list.count(d) :d的总数
       list.pop() ： 弹出
       list.insert(a,b) : a 索引  b 参数
       list.remove(a)  : 参数为删除元素 如果有多元素，默认删除第一个
       list.index()  : 索引值
       list.reverse()
       list.sorted()  既可以保留原来list  也可获得新的排序sort不行


  4.续行
      \      ‘’‘  这个是闭合操作符，单一语句跨多行
      每个模块都存在__name__ 的内建变量
      __name__ 指示模块应该如何被加载
      （1） 如果模块是被导入的，__name__的值是模块名字
       （2） 如果是直接执行 __name__ 的值为’__main__‘
  5.实例被创建后，其身份和类型就不可变
        对象值变化为可变对象
        不可变化的为不可变对象
        instance : 实例化
       操作实例化的类
           类.属性 类.方法名
  6. 数字： int long float complex bool
     字符： str unicode
     列表：list
     字典： dict
     元组：tuple tuple tuple
     文件 ： file
     其他 ： 集合set    None  frozenset
     其他文件类工具 pipes fifos sockets
  类型显式转换
    str() repr() format() 将非字符数据转换字符
    python强类型语言 强制转换repr() str()
    int() 转换整型
    float() 浮点型
    list() 列表
    set() 集合
    tuple()
    dict() 对象必须是键值对
    chr()   整形换字符型
    bin()   换二进制
    ord()   字符换整数
    hex()    整数换16进制
    oct()
  运算符
  // 截断除  ** 乘方   % 取模 -x 一元减法 +x
  比较
  x << y  左移  x 按位移>> 右移
   x & y  按位与   x | y 按位或  x ^ y 按位异或
   -x 按位求反


  8.序列类型
       字符类型  单，双，三引号中
       max() min() lens()
       captitalize(s) 首字符大写
       index(s) 手持出现位置
       index(s,5,8) 5指开始 8结束
       支持类型  ： 对象的自有操作
       列表  ：  容器类型
       （1）任意对象的有序集合，通过索引访问其中的元素，可变对象
       异构，任意嵌套
       （2）修改指定位置的元素（根据索引值）
       list.insert(list[‘1‘],s)
       list.pop(list[‘3‘]) 弹出某个值
       L1 + L2 合并成新列表
       L1 * N  把L1重复n次
       in 成员关系判断  item in container
       not in  成员关系判断  不在里

       元组  （)
       不可变对象,长度固定
       但如果元组内嵌套了可变的类型的元素，那么此类元素的修改不会返回新元组

       常见操作
       （）
       （1，）
       （1,7）
       t* N 重复元组
       in     not in  等同list

       定义元组可以删略小括号


       字典 dict {}
       字典在其他语言里又称为关联数组或散列表 通过建实现元素存取
       无序集合，可变类型容器  长度可变支持异构 嵌套
       dict.clear() 清空
       .copy()
       .get(key)
       .has_key(key) 返回 true false
        .items()  把减值转换成元组列表的形式
        v1,v2 = t.items()  变量解包   两边徐匹配
        .values()   去除建保留值得列表
        .popitem()  弹出其中的减值 随机的
        .update(t2)   键一样会覆盖掉



        t1=t.iteritems()   返回迭代器对象
        t1.next()
        t1.next()
        .
        .
        .

        获取使用帮助；
            获取对象支持使用的属性和方法  ：dir()
            某方法具体使用  help(list.pop)
            获取可调用对象的文档字串  print obj.__doc__
        集合  ： 无序排列  可哈希
               支持  in  not in   迭代
               无法索引 。元素获取  切片
        集合类型  set() frozenset()
         s,copy()
         s.difference(t)  求差集
         s.intersection(t) 求交集
         s.isdisjoint(t)  st无相同项 返回true
         s.issubset(t)  s为他  子集  true
         s.issuperset(t)  s为t 超级  true
         s.union(t)   求并集
         s | t  并集
         s & t 交集
         s - t 差集
         s ^ t  对称差集


python 的表达式和语句
          表达式 ：
          x+y  x-y
          x * y   x/y    x // y   x % y
          逻辑  or  and  not
          关系   in     not in
          对象实例测试   is     not is
          比较   >  <   <=  >=  ==  !=
          位运算   |      &    ^    <<   >>
          一元运算    -x   +x   ~x
          幂运算  **
          调用 x(...)
          去属性  x.attribute
          元组 （）   序列[]    字典  {}

          三元选择   x  if y else z
运算优先级
    () [] {}
    s[i] s[i:j]
    s.attribute
    s(...)
    +x -x ~x
    x**y
    *  /  //  %
    +  -
    <<  >>
    &
    ^
    |
    <  <=  > >=  =  !=
    is   not is
    in   not in
    not
    and
    or
    lambda
    由高到di


    语句
     赋值语句
     调用语句
     print： 打印对象
     if/elif/else
     for/else
     while/else
     pass : 占位符
     break
     continue
     def
     return
     yield
     global
     raise :触发异常
     import
     from  模块属性访问
     class
     try/except/finally
     del  删除引用
     assert   调试检查
     with、as  环境管理器

     python对象的真假
     1. 任何非零和非空对象都为zhen
     2.数0  空对象  特殊对象none都为假
     3.比较和相等测试会递归的应用数据结构中
     4.返回值为true 或 false



     while 循环操作
      break ：  跳出最内层的循环
      continue : 跳出最近的循环
      pass  点位语句
      else  循环停止才会执行 如果循环总值使用break 则不会执行else语句

迭代  ：重复做一件事      判断对象是否 是迭代对象
        from  collections import Iterable
        isinstance(param,Iterable)
iterable 可迭代对象
      支持每次返回自己所包含的一个成员的对象
      对象实现了__iter__ 方法
          1.list str tuple  2.无序的dict file
          3.用户之定义一些包含了__iter__() 或__fetitem__()方法的类

      迭代器是一种特殊的数据结构，当然在Python中，它也是以对象的形式存在的
           简单理解方式：对于一个集体中的每一个元素，想要执行遍历，那么针对这个集体的迭代器定义了遍历集体中的元素顺序或者方法
           d = iter(dd)  迭代
           d.next()
           ..........
           使用iter()可从任何序列对象中得到迭代器
           若实现迭代器，在类中定义next()方法 p3中是__next__()
           迭代器指向下一个元素用成员函数next()
           python 是函数next() 非成员函数
           没有元素是引发stopiteration 异常
           for循环可用于任何迭代对象
             循环开始时，会通过迭代协议传递iter()内置函数，从而能够从可迭代对象中获取一个迭代器，返回的对象含需要的next方法
             迭代器样式: 列表解析[()]
      生成器表达式不是真正的创建数字列表，而是返回一个生成器对象
      吃对象在每次计算出一个条目后，把这个条目“产生”出来
            生成器表达式使用了“惰性计算”或者“延迟求职”的机制
            序列过长，并且每次只需要获取一个元素的时，先考虑用生成器而不是列表解析
            语法
            （expr for  iter_var in iterable）

        for i,value in enumerate([‘a‘,‘b‘,‘c‘])
             print(i,value)     //键值对