一口气学会 Python

Python 是一种语法简洁、面向对象的编程语言。 广泛应用于人工智能、数据分析等领域。

---

input("请输入数据")                        // 统一按字符串的形式接收

int(input("请输入一个整数: "))        // 强制转换

print("Hello world")

---

range([start,] stop [,step]) 函数 ：逐步产生从 start = 0 到 stop-1 步长为 step = 1 的正序数字

countdown(n) 生成器函数：逐步产生从 n 到 1 的倒数数字（功能同迭代器，见后文）

一、基础知识

1、声明

（1）变量声明：直接赋值即可创建各种类型的变量，该变量在程序执行期间可以有不同的值。
                name = " 李华"
                age = 18                                     // 句尾分号可省
                here = there = that = 1024

（2）类型转换：变量的类型可以随时发生变化，可通过强制类型转换变为其他类型。
                age = 18
                print(type(age))                         // type() 函数输出 age 的类型
                age = float(age)                        // 强制类型转换

2、类型

（1）number 类型：包括 整型 (进制)、浮点型、复数型 三种类型。
                a=123456
                c=2.2+5.6j                                // 该复数类型的实部和虚部都是浮点数
                b=12.3456

（2）boolean 类型：此类型由 true 和 false 两个逻辑值组成，常用在条件语句中。
                isDone = false
            ... if (isDone)   
                        print('Done!')                                         // python 中用缩进代替花括号

（3）string 类型：由单引号或双引号括起来的，零个或多个字符组成的字符序列。
         字符串是静态不可变的字符序列。操作字符串时，实际上会创建一个新的字符串对象。
                s1 = 'Hello, world! \n';                                   // 转义字符
                s2 = 'this is a ' + 'string';                               // 拼接
                print("Hello  %s  %d"  %(name %age))        // 占位(%s, %d, %f)
                print(f"Hello  {s1}")                                       // 不占位(f-string)

（4）list 类型：列表元素可以是任意类型，可以动态更新。
                e =  [123, "runoob"]

（5）tuple 类型：元组元素可以是任意类型，静态不能修改（与列表最大的不同）
                f =  (123, "runoob")

（6）dictionary 类型：字典是一种动态可变容器，无序，能以键值对的形式存储任意类型对象。
                g =  { "name": "runoob", "code":1 }        // “键”必须唯一

（7）set 类型：集合是一个无序、不重复的元素序列，且可以进行交/并/差等常见的集合操作。
                h = { "Google", "Taobao",  "Facebook" }

3、运算符

（1）赋值运算：+=、-=、*=、/=、%=、<<=、>>=、>>>=、&=、|=、^=

（2）比较运算：===、!==、==、!=、>、>=、<、<=

（3）算术运算：-、+、--、++、*、/、%

（4）逻辑运算：a&&b、a||b、!a

（5）位运算：a&b、a|b、a^b、~a、a<<b、a>>b、a>>>b

（6）成员运算符：in、not in                // 返回 boolean 类型

4、语句

（1）If 语句：条件为真时，执行对应的语句，否则执行另一组语句，else 中也可能包含 if 语句。
                let s1 = 'Hello';
                if (s1) { ... }                              // 对 boolean 以外的类型，会进行隐式类型转换
                elif (condition2) { ... }              // 若是双向判断，可用三目运算符替代
                else { ... }

（2）switch 语句：使用 switch 语句，来执行与 switch 表达式值匹配的代码块。
                switch (expression) {
                        case label1:                              
                                ...; break;                          // break 可选               
                        case label2 :
                        case label3:                             // 如果 label2 或 label3 匹配，则执行
                                ...; break; 
                        default:   ....                             // 默认语句，可省略
                }

（3）条件表达式：由第一个表达式的布尔值，来决定返回其它两个表达式中的哪一个。
                let isValid = Math.random() > 0.5 ?  true : false;

（4）for 语句：for 语句会被重复执行，直到循环退出语句值为 false
                for ([init]; [condition]; [update]) {  ...  } 

（5）while 语句：只要 condition 为真值，那么 statements 语句会重复执行。
                while (condition) {  ...  }

（6）break 语句、continue 语句
         break 语句可以终止循环语句或 switch
         continue 语句会停止当前循环迭代的执行，并将控制传递给下一个迭代。

（7）pass 语句：该语句没有任何功能，它是一个空语句，一般被用于充当占位的作用

二、函数

1、声明函数

函数声明通过 def 关键字引入一个函数，包含其名称、参数列表、返回类型和函数体。
                def  function_name() :
                        print('调用函数')
                        print('人生苦短，我用Python')
                helloworld()
                print('调用完毕')

                A = 30
                def get_salary(days):
                        salary  = days * 300
                        print(salary)
                get_salary(A)                        // 调用时，参数的数量和位置需要和创建的保持一致

2、关键字参数

                def volume(length , width , height) :
                        volume = length * width * height
                        print('体积为：',volume)
                volume(length = 20, width = 30, height = 3)

                def volume(length = 100,width = 100,height = 100):
                        volume = length * width * height
                        print(volume)
                volume()                              // 不给实参时，将会使用默认参数
                volume(10,10,10)

3、可变参数

Python 中函数的参数个数可以变化，即参数的数量可以是不确定的，这种参数被称为可变参数。
可变参数分为两种：
        （1）将任意数量的位置参数，打包成元组：def function_name(*args)：...
        （2）将任意数量的位置参数，打包成字典：def function_name(**kwargs)：...
                def add_number(*number):
                        add_num = 0  
                        for i in number :
                                add_num += i
                print(add_num)
                add_number(1,2,3,4,5)

4、返回类型

当我们在使用函数的时候，可以增添一个 return 语句来获取函数中的一些数据。
                def get_sum(a,b) :
                        sum = a + b
                        print('调用了这个函数')
                        return sum
                print('完成返回值的传递')
                s = get_sum(1,2)

                def  get_data():
                        a = 1
                        b = 2
                        return  a,b                                                // 多值返回时，值会被存储在元组当中
                print( '返回值的类型 : ' , type(get_data()))
                i, o, k, l = get_data()
                print(i , o , k , l)

5、函数作用域

（1）函数中定义的变量和其他实例，仅可以在函数内部访问，不能从外部访问。
（2）函数内定义的变量也可以编程全局变量，使用 global 关键字即可。

     函数调用：调用函数以执行其函数体，实参值会赋值给函数的形参。
                data = '这里是全局变量data'
                def  test() :
                        global data                                // global 关键字使一个变量变为全局变量
                        print(data)
                test()

6、匿名函数

在 Python 中，匿名函数即 lambda 函数，它是一种没有函数名的小型函数。
                m = int(input('请输入一个数字:'))
                a = lambda  x :  x + 10 * 10 + x * x                // 语法：lambda 参数 : 表达式
                print('返回值为：',a(m))

三、类

Python 作为一种面向对象的编程语言，支持面向对象的所有特性，万物皆为对象。

1、基本概念

类：对象的模板，拥有所有对象的共同特征和属性（抽象）
对象：具体的个体，拥有一组属性和方法的集合（具体）
属性：描述对象特性的数据，即若干变量。                        
方法：操作对象的若干动作，即若干函数。                        
static 修饰的 变量/方法，只此一份，被所有对象共享，可以直接通过类名调用。

2、声明类

定义类：class  class_name：成员变量 (属性)  +  构造方法  +  成员方法
         self 代表当前对象。self.x = x , 表示把方法参数的值 (局部变量) 赋给当前对象的成员变量
                 class people：
                        name = ' '                                                           // 成员变量（属性）                      
                        def  __init__(self, n)：                                       // 构造函数，第一参数推荐为 self
                                self.name = n  
                        def  speak(self)：                                               // 成员方法
                                print("%s 说：Hello！" %(self.name))

3、使用类

直接创建对象：object_name = class_name()再通过“.”操作符，使用这个对象的属性和方法

4、继承类

继承类：class child_Name(Base1 , Base2 , Base3)：...
1、子类可以直接使用父类的非私有属性和方法（使用 super 关键字）
2、子类可以重写父类的方法，以实现更具体或不同的行为。

序列：字符串+列表+元组

（1）支持索引：正方向从 0 开始，即 0, 1, 2, ...；反方向从 -1 开始，即 -1, -2, ...
（2）支持切片：序列名[ 起始下标：结束下标：[步长] ]，左闭右开，返回一个新序列
（3）支持运算：检查（成员运算）、拼接（加法运算）、重复（乘法运算）...
（4）支持遍历、统计、排序、类型转换（见后文）

数据容器：序列+字典+集合

（1）支持遍历：都支持 for...in 遍历，此外，序列还支持 while 循环 (通过索引）
（2）支持统计：len(数据容器)、max(数据容器)、min(数据容器)
（3）支持排序：sorted(数据容器, [reverse = True] )，降序排序，得到 list 对象
（4）支持类型转换：list(数据容器)、tuple(数据容器)、str(数据容器)、set(数据容器)
（5）支持迭代器 (还有生成器)
        1、创建迭代器对象：it = iter(数据容器)
        2、迭代器的下一个元素：print ( next(it) )
      注：从第一个元素开始访问，只往前不后退，只访问一次，直到所有元素都被访问完