python 基础

python

注释

• 中文注释

  # -*- coding = 'utf-8' -*-
  

缩进

• 保留字

• 标识符

常量

字符串

• <string>.upper() #字母大写
• <>.lower() #小写
• <>.strip #去左右空
• <>.find() #搜索 也可用来遍历
• <>.replace() #替代
• for <var> in <> #迭代

计数

• 用j J 表示虚数

  print(3 + (2j),3 + (2j)**2, (3 + 2j)** 2)
  # (3+2j) (-1+0j) (5+12j)
  

变量

• 谨慎使用‘ oO ‘来命名

数据类型转化

• repr(x) 转化为表达式字符串
• ord() 转化为整数

my_str = 'sadasd\
sadada'
my_str ='asdasda'\
'asdasda'
print(my_str)

print(3 + (2j),3 + (2j)**2, (3 + 2j)** 2j)

a = 1 
b = 2
print(a + b)
a = 1.1
b = 2.2
print(a * b)


def mm(a , b):
    if a > b:
        print('第一个大')
    elif a < b:
        print('第二个大')
    else:
        print('一样大')
mm(1, 2)
mm(2,1)
mm(1,1)


a = 1.1
print(a +1)

数据结构

列表 list

my_list = []
print(type(my_list))

遍历

mytlist = []
for index,each in enumerate (mylist):
    print(index)
    print(each)

####修改

1. mylist[2] = 'new_str'

####删除

1. 索引删除

   del list[2]

   直接删除列表

2. 元素值来删除

   list.remove('列表元素')

   list.remove[2]、

   删除元素

####增加

1. 追加

   list.append()

2. 插入

   list.insert(索引位置，元素值)

####查

1. list[ index ]
2. value in list 判段 bool类

元组

不可变的 不可修改 不可删除 不可增加

只能销毁 del tuple

查

字典 dict

无序

创建

1. 键要唯一

增加

1. dict[键] = '值'

删除

1. dict.pop('key')
2. dict.clear() 清空
3. dict.popitem() 随机删除

修改

key不存在添加，存在修改

1. dict[key] = 'value'
2. dict.

查询

1. dict[key]

   没有则报错

2. dict.keys() 返回所有key 类型列表

3. dict.values() 返回值 相同的都会返回

4. dict.items() 返回k-v键值对

流程控制

顺序语句

选择结构

判断是 如果是常量（除了false，0）都判定为真。如果为变量，空的列表或者其他（none），判定为假。其他为真

循环结构

for i,e in enumerate():

for

mystr = '123456789'
for i,each in enumerate(mystr):
    print(i,end = ' ')
    print(each,end='')
    print()

print('-'*40)
mytuple = (1,2,3,3,6,4,4)
for item in mytuple:
    print(item)

for index, item in enumerate(mytuple):
    print(index,'->',item)

print('*'*40)
mydict = {1:'a',2:'b',3:'c'}
for key in mydict.keys():
    print(key)
for value in mydict.values():
    print(value)
for key,value in mydict.items():
    print(key,'->',value)
for key,value in enumerate(mydict):
    print(key,'->>',value)

while

while 内一定要写自增后自减

while i < len(mystr):
    print(mystr[i])
    i += 1

函数

def fun([parameterlist]):
    ['''comments''']
    [functionbody]

三要素： 函数名 参数 返回值

####内置函数 callable()

测试对象是否可调用，可以返回TRUE

divmod

divmod(被除数，除数) 返回元组（商，余数）

pow(x,y[,z])

x的Y次方 有Z则为x的Y次方被Z取模

1. 冒泡排序

   def bubble_sort(numlist) -> None:
       N = len(numlist)
       for i in range(N - 1):
           for j in range(N - i - 1):
               if numlist[j] > numlist[j+1]:
                   numlist[j],numlist[j+1] = numlist[j+1],numlist[j]
       #bubble_sort end
   num_list = [19,2,13,8,34,25,7]
   print('排序前：',num_list)
   bubble_sort(num_list)
   print('排序后：',num_list)
   print('排序后%s%s'%(num_list,type(num_list)))
   
   

面向对象

类 class

函数分类：

1. 实例函数 eg __init__():
2. 类函数
3. 静态函数

定义

class Animal:
    def walk(self):# 至少要有一个参数，命规则没有强制要求
        print('I am working')
      
a = Animal()
a.walk()

实例函数

类函数

class Animal:
    def walk(self):
        print('I am working')
    @classmethod   #当做类函数
    def myckassFun(cls):# 至少一个参数 ，命名规则没有强制要求
        print('I am class function')
      
a = Animal()
a.walk()

静态函数

class C:
    @stacticmethod
    def mystaticFunc():# 可以没有参数
        print('I am static function')

访问的区别

实例函数访问必须通过对象变量

构造函数

命名唯一

class C:
    __init__(self):
        self.[参数]

继承

class A():
    def __init__(self):
        print('A init')

        self._name = 'sa'

class B(A):
    def __init__(self):
        print('B init')
        super().__init__()


a = A()
b = B()
print(a._name)