python基础语法

python基础语法

1. ipython

ipython 在python命令交互加入了命令机制

2.注释

单行注释：#

多行注释：'''注释内容‘’‘或者"""注释内容"""

3. python2注释中文有问题

在*.py开头加入：#coding=utf-8或者#-*- coding:utf8 -*-

4. input

• 在python2中 input当做代码执行，用raw_input()与python3的使用是一样的
• python3中input内容默认为字符串

5. 数据类型转换

int(x[,base])
long(x[,base])
float(x)
complex(real[,imag]) 转换成复数形式
str(x)
repr(x) 转化为x的表达式字符串
eval(str) 计算表达式
tuple(s) 序列转元组
list(s) 序列转列表
chr(x) 整数转字符
unichr(x) 整数转unicode字符(python3中用chr)
ord(x) 字符转整数
hex(x) 整数转16进制字符串’0x…’
oct(x) 整数转8进制字符串’0o…’
bin(x) 整数转2进制

6. if中条件语句

== != <> > < >= <= x and y x or y not x is

7.python中的关键字

import keyword
keyword.kwlist

[‘False’, ‘None’, ‘True’, ‘and’, ‘as’, ‘assert’, ‘async’, ‘await’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘nonlocal’, ‘not’, ‘or’, ‘pass’, ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, ‘yield’]

8. 算术表达式

= - * / // % ** += -= *= /= //= **=

9. print多个值

print("%s, %d"%(str, num))

10. if组合

if 条件1：
	...
elif 条件2;
	...
else:
    ...

注意：一般情况下，if嵌套为两层以下。

random.randint(0, 2)

11.随机数

import random
random.randint()

12. 字符串

1. 字符串组成的两种方式

   a = "lao"
   b = "wang"
   c = "li"
   c = a + b
   d = "%s"%(a + b)
   e = a * 20
   

2. 字符串的访问

   • 下标：name[0]
   • 子串访问name[2:6] name[2:-1] name[2:-1:2]
   • 逆序:name[-1:0:-1] name[-1::-1] name[::-1]

3. 字符串常见操作：https://www.runoob.com/python3/python3-string.html

   • 查找索引等

     1. find(str, beg=0, end=len(string))

        检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1

     2. rfind(str, beg=0,end=len(string))

        类似于 find()函数，不过是从右边开始查找.

     3. index(str, beg=0, end=len(string))

        跟find()方法一样，只不过如果str不在字符串中会报一个异常。

     4. rindex( str, beg=0, end=len(string))

        类似于 index()，不过是从右边开始.

     5. count(str, beg= 0,end=len(string))

        返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数

     6. endswith(suffix, beg=0, end=len(string))

        检查字符串是否以 suffix 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.

     7. startswith(substr, beg=0,end=len(string))

        检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。

   • 字符替换等

     1. [replace(old, new )] (https://www.runoob.com/python3/python3-string-replace.html)

     把将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。

     2. capitalize()

        将字符串的第一个字符转换为大写

     3. title()

        返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())

     4. lower()

        转换字符串中所有大写字符为小写.

     5. upper()

        转换字符串中的小写字母为大写

   • 字符串的判断

     1. isalpha()

        如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False

     2. isdigit()

        如果字符串只包含数字则返回 True 否则返回 False.

     3. isalnum()

        如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False

     4. islower()

        如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False

     5. isupper()

        如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

     6. isspace()

        如果字符串中只包含空白，则返回 True，否则返回 False.

   • 字符串的对齐、格式、分割等

     1. split(str="", num=string.count(str))

        以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串

     2. [_splitlines(keepends])

        按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

     3. center(width, fillchar)

        返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。

     4. ljust(width[, fillchar])

        返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。

     5. [ rjust(width,, fillchar])

        返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串

     6. lstrip()

        截掉字符串左边的空格或指定字符。

     7. rstrip()

        删除字符串字符串末尾的空格.

     8. [strip(chars])

        在字符串上执行 lstrip()和 rstrip()

     9. partition

        #!/usr/bin/python
          
        str = "www.runoob.com"
         
        print str.partition(".")
        

13. 列表

• 增：list.append() list.insert(位置, 内容) list1+list2 list.extend(list1)

• 删：list.pop() list.remove(元素) del list[index] list.clear()

• 查： list[0] list[0:3]

• 改： list[index] = 元素

  list更多详解：https://www.cnblogs.com/fu-yong/p/8066422.html

• 切片

  a = [1:6] # a = [1, 2, 3, 4, 5]
  b = [1:6:2]	# a = [1, 3, 5]
  

• 列表生成式

  a = []
  b = []
  a = [i for i in range(1, 18)]
  d = [(i,j) for i in range(3) for j in range(2)]
  

• 列表去重

  a = [11, 22, 33, 11, 22, 44]
  type(a) # 列表
  b = set(a)
  print(b)	# b = [11, 22, 33]
  a = list(b)
  

14. 元组

• 一般函数返回多个参数时，默认以元组形式

• 元组只有一个元素时需要多加一个, ，如：(3,)

• 增：dict_name[keyword] = value

• 删：del dict_name[keyword]

• 查：dict_name.get(keyword)

• 改：dict_name[keyword] = new_value

• 其他

  dict_name.keys()

  dict_name.values()

  dict_name.items() 返回[(key, value), (key, value)…]

  del dict[key] 删除，不存在出错

  .get(key) 获取key的值，不存在返回None

16. append与extend的区别

append() 方法用于在列表末尾添加新的对象。
extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

list_name = [1, 2, 3, 4]
list_name_a = [1, 2]
print(list_name.extend(list_name_a))   #display: [1, 2, 3, 4, 1, 2]
print(list_name.append(list_name_a))	#display: [1, 2, 3, 4, [1, 2]]

17. 函数

• 函数结构

  def func_name(a, b=default, c=default):
      '..' or ''..'' or '''..''' or """.."""
      # 函数文档说明
      # 上述四种函数内的注释都为函数的help说明   即help(func_name)
      ...
      ...
      return 	x, y, z  # 其中返回的默认为一个元组，也可以return [x, y, z]
  

• 全局变量

  在函数内，普通变量必须要在函数内重新定义一下globle var,但字典和列表不加也可以直接使用

  def func_name(a, b=default, c=default):
      global var
      var = 123
      ...
      return	xxx
  

• 函数中的参数

  def func_name(a, b, c=100, *args, **kwargs):
      '''
      其中a,b为命名参数
      c为缺省参数
      args为不定长参数，存放的为调用时没有名称的变量，以元组(tuple)形式存储
      kwargs存放的为带有名称且不为命名参数的变量，以字典(dict)形式存储
      '''
      ...
      return xxx
  

• 拆包

  def func_name(a, b, c=33, *args, **kwargs):
      ...
      return xxx
  A = {44, 55, 66}
  B = {"name": "king", "age": 24}
  func_name(11, 22, 33, *A, **B)
  # 上述对A和B进行拆包，A将元组拆分传递给func_name()中的args，B拆分传递给kwargs
  

• 不可变的类型：数字、字符串、元组（都可作为dict中的key）

  a = (1, 2)
  dict  = {}
  dict[a] = "aaaa"
  print(dict)   # {(1, 2):"aaaa" }
  

• 匿名函数lambda

  格式：lambda 参数:返回值

  # lambda用于字典中
  infors = [{"name":"laowang","age":10},{"name":"xiaoming","age":20},{"name":"banzhang","age":10}]
  infors.sort(key=lambda x:x['age'])
  print(infors)
  
  
  # lambda用于实参
  def test(a,b,func):
      result = func(a,b)
      return result
  
  num = test(11,22,lambda x,y:x+y)
  print(num)
  
  
  #lambda作为输入匿名函数
  def test(a,b,func):
      result = func(a,b)
      return result
  func_new = input("请输入一个匿名函数:")
  func_new = eval(func_new)
  num = test(11,22,func_new)
  print(num)
  

18. 交换两个数值的3中方法

#第1种
c = 0
c = a
a = b
b = c

#第2种
a = a+b
b = a-b
a = a-b

#第3种
a,b = b,a

19. 关于+与+=的区别

• list 上使用 += 的时候，其实相当于调用函数 extend()，可以使用现有的空间。
• 调用 + 时，将会创建一个新的对象，并复制里面的所有内容

如果你写 X += Y，在其他对列表的引用(reference)中，会看到变化；但如果你使用 X = X + Y，就不会。

20. 文件操作

f = open(file_name, "way") # way可选[r, w, a, rb, wb, ab, r+, w+, a+, rb+, wb+, ab+]
f.read(length)	# 返回读取length长度的内容，默认全部，读到结尾返回空字符串
f.write(str)	# 写内容，返回的是写入的数量
f.close()	# 文件的关闭
f.readline()	# 读取一行数据 以\n结尾
f.readlines()	# 读取文件所有内容，以列表存储每行内容
f.seek(offset,from)	# 文件指针偏移， from = 0表示从头，1 表示从当前位置， 2表示从文件尾
f.tell()	# 当前位置

21. os的使用

import os
os.rename(old_name, new_name)	# 文件重命名
os.remove(name)	# 文件删除
os.mkdir("file_name")	# 创建文件夹
os.rmdir("file_name")	# 删除文件夹
os.getcwd()	# 返回当前路径
os.chdir("path")	# 更改当前路径
os.listdir("path")	# 获取目录列表，以list存储

22. 类(class)

class 类名(父类):
    def __init__(self, 参数):
        ...
    def __str__(self):
        return xxx	# 当print(对象)时候 就会打印xxx
    def func():
        ...

• 私有属性

  self.__age = 0 # 该属性只能在对象内访问 外部不能访问
  

• 私有方法

  def __func(self):	# 该方法在外部也不能调用
      pass
  

• __del__方法

  def __del__(self):
      pass
  # 在外部调用 `del 对象名` 会调用__del__方法完成清理工作
  

• 继承

  class Name(父类名):
      pass
  

• 方法被重写调用父类的方法

  # 第一种
  Dog.bark(self)
  # 第二种
  super().bark()
  

**注意：**私有方法与私有属性并不会被继承

• 多继承

  class A():
      pass
  
  class B():
      pass
  
  class C(A, b):
  	pass
  

  使用C.__mro__魔法函数可以查看当前对象中方法的优先级，该优先级的判定是根据拓扑排序算法进行排序的。

  (__main__.C, __main__.A, __main__.B, object)
  

• 多态

  class A():
      def print_self():
          pass
  
  class B():
      def print_self():
          pass
  
  def introduce(temp):
  	temp.print_self()
      
  a = A()
  b = B()
  # 多态
  print(introduce(a))
  print(introduce(b))
  

• 实例方法、实例属性、类方法、类属性、静态方法

   class Game(object):
          # 类属性
          num = 0
          # 实例方法
  		def __init__(self):
              # 实例属性
              self.name = "laomao" 
              
              
          # 类方法
          # 一般用于对类属性操作
          @classmethod
          def add_num(cls):
              cls.num = 100
              
              
          # 静态方法
          # 一般用于对非类属性、非实例属性的使用
          @staticmethon
          def print_menu():
              pass
          
          
  game = Game()
  # 可通过类名调用类方法
  Game.add_num()
  # 可通过对象调用类方法
  game.add_num()
  
  
  # 通过类名调用静态方法
  Game.print_menu()
  # 通过实例对象 去调用静态方法
  game.print_menu()
  

• __new__的使用

   class Dog(object):
      def __init__(self):
        print("----init方法-----")
  
      def __del__(self):
          print("----del方法-----")
  
      def __str__(self):
          print("----str方法-----")
          return "对象的描述信息"
  
      def __new__(cls):#cls此时是Dog指向的那个类对象
  
          #print(id(cls))
  
          print("----new方法-----")
          return object.__new__(cls)
  
  
  #print(id(Dog))
  
  xtq = Dog()
  

  在python中，创建一个类实例，要做3件事：

  1. 调用__new__来创建对象，然后找到一个变量来接收__new__的返回值，这个返回值表示创建出来的对象的引用。
  2. __new__(刚刚创建对象的引用)
  3. 返回对象的引用

• 创建单例对象并且只初始化一次

  class Dog(object):
  
      __instance = None
      __init_flag = False
  
      def __new__(cls, name):
          if cls.__instance == None:
              cls.__instance = object.__new__(cls)
              return cls.__instance
          else:
              #return 上一次创建的对象的引用
              return cls.__instance
  
      def __init__(self, name):
          if Dog.__init_flag == False:
              self.name = name
              Dog.__init_flag = True
  
  
  a = Dog("旺财")
  print(id(a))
  print(a.name)
  
  b = Dog("哮天犬")
  print(id(b))
  print(b.name)
  

23. 异常

• 异常处理

  try:
      num = input("xxx:")
      #11/0
      # open("xxx.txt")
      print("---------1----------")
  except NameError:
      print("这里是NameError....")
  except (FileNotFoundError, IOError):
      print("这里对于两种异常做同样的处理")
  except Exception as result:
      print("其他异常：")
      print(result)
  else:
      print("没有异常会执行的功能")
  finally:
      print("---无论有没有异常都会执行这里的功能-----")
      
  print("-----------2--------------")
  

• 抛出自定义异常

  class ShortInputException(Exception):
      '''自定义的异常类'''
      def __init__(self, length, atleast):
          # super().__init__()
          self.length = length 
          self.atleast = atleast
     
  def main():
      try:
          s = input("请输入-->")
          if len(s) < 3:
              # raise引起一个自定义的异常
              raise ShortInputException(len(s), 3)
      except ShortInputException as result
      	print("ShortInputException: 输入的长度为：%d, 长度至少为；%d"%(result.length, result.atleast))
      else:
          print("没有异常发生")
  
  main()
  

• 异常处理中抛出异常

  class Test(object):
      def __init__(self, switch):
          self.switch = switch
      def cal(self, a, b):
          try:
              result = a / b
          except Exception as result:
              if self.switch:
                  print("捕获异常开启，已经捕获到异常，信息如下：")
                  print(result)
              else:
                  # 重新抛出正异常，此时就不会被这个异常处理捕获到，从而触发默认的异常处理
                  raise
  

24. if的判断条件

# 若变量为0、空字符串、空列表、空字典、None。上述print都不会执行
if 变量:
	print("--------")

# 条件成立执行print
if xxx == yyy:
    print("-------")
    

25. 模块

• 系统默认模块路径的查看

  import os
  print(os.__file__)
  # 可以查看os模块所在的路径
  

• __all__的使用

  1. 在*.py中的作用：规定导入该模块时可以使用哪些功能

     __all__ = ["test", "num"] # import时只能使用test和num 而不能使用Test2
     def test():
         pass 
     
     def Test2():
         pass
     
     num = 100
     
     

  2. 在__init__.py中的作用：规定导入包时能够使用哪些模块

     __all__ = ["sendmsg"]  # 可在使用
     
     from . import sendmsg
     

     下列是关于TestMsg包的目录结构

     [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xL3VZijC-1608119098020)(https://s3.ax1x.com/2020/12/12/rVa8Gn.md.png)]

• 包

  包必须是一个文件夹，文件夹下必须有__init__.py。

• 模块的发布与安装

  1. 创建setup.py文件

     setup.py文件与包名同级，不在包里面

     from distutils.core import setup
     
     setup(name="package",  # 包名
           version="1.0",  # 版本
           description="xxx's 各个模块的作用功能",  # 描述信息
           long_description=" 各个模块完整的功能",  # 完整描述信息
           author="xxx",  # 作者
           author_email="xxx@aa.com",  # 作者邮箱
           url="www.xxx.com",  # 主页
           py_modules=["包名.模块名1",
                       "包名.模块名2"])
     

  2. 构建模块

     Linux下构建

     $ python3 setup.py build
     

     Windows下构建

     例: python.exe地址 setup.py build
     E:\untitled1>C:\Users\zm\AppData\Local\Programs\Python\Python38-32\python.exe setup.py build
     

  3. 生成压缩包

     Linux下生成压缩包

     $ python3 setup.py sdist
     

     Windows下生成压缩包

     例: python.exe地址 setup.py sdist
     E:\untitled1>C:\Users\zm\AppData\Local\Programs\Python\Python38-32\python.exe setup.py sdist
     

     注:生成的压缩包文件在python的项目地址中,这里在E:\untitled1\sdist文件里

  4. 拿到别人分享的压缩包后，安装模块

     $ tar -zxvf 包名-1.0.tar.gz
     $ sudo python3 setup. py install
     

26. 给程序传参数

import sys
print(sys.argv)	# ["程序名"，参数1, 参数2...]

argparse的使用

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-task", default=abs, type=str, choices=["abs", "ext"])
parser.add_argument("-max_length", default=150, type=int)
args = parser.parse_args()
print(args.task)	# abs
print(args)	# Namespace(max_length=150, task=<built-in function abs>)

 python3 setup.py sdist
     ```

     **Windows下生成压缩包**

     ```bash
     例: python.exe地址 setup.py sdist
     E:\untitled1>C:\Users\zm\AppData\Local\Programs\Python\Python38-32\python.exe setup.py sdist
     ```

     > 注:生成的压缩包文件在python的项目地址中,这里在E:\untitled1\sdist文件里

  4. 拿到别人分享的压缩包后，安装模块

     ```shell
     $ tar -zxvf 包名-1.0.tar.gz
     $ sudo python3 setup. py install
     ```



##### 26. 给程序传参数

```python
import sys
print(sys.argv)	# ["程序名"，参数1, 参数2...]

argparse的使用

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-task", default=abs, type=str, choices=["abs", "ext"])
parser.add_argument("-max_length", default=150, type=int)
args = parser.parse_args()
print(args.task)	# abs
print(args)	# Namespace(max_length=150, task=<built-in function abs>)