1.变量

1.什么是变量：
        在程序运行时，可以发生变化的量

2.python如何定义变量：

        java、c、c++、c#都是强数据类型语言

                        数据类型  变量名 = 变量值

                       eg：int a = 10;

        python、JavaScript、PHP等编程语言都是弱数据类型语言

                       变量定义时，不用强调变量的 数据类型，类型由值决定

                        var 变量名称 = 变量值

                        而python中连var都省略了；

                         变量名称 = 变量值

        （标识符）变量的命名规则：

                 【强制规则】
                        ·标识符只能由【数字、大小写字母、_下划线、各国的语言符号】这些有效符号组成

                        ·数字不能开头

                        ·不要使用关键字或者保留字

                  【非强制规则】

                         ·变量名尽量有意义

                        · 多个单词组成的标识符，建议使用小驼峰法或者下划线发、大驼峰法

                                        python官方推荐使用：小驼峰法

2.Python中的数据类型：

规则：

语法格式： 变量名 = 值
变量名：单词小写，如果有多个单词，用下划线来连接_
       lower_case
代码规范： 定义变量时，赋值运算符=的左右两边 各有一个空格

 概念：

        整型：int

        浮点型：float

        布尔型：bool(boolean)

        字节型：bytes

        字符：    char(Python中没有char类型)

        字符串：string

        列表：     list

        字典：     dictionary

        集合：      set, collection

        元组：      tuple        （内建的不可变的序列）

具体Python中的数据类型：

        

        整型：int   1，2，3，4........整数（正整数，负整数以及零）

        小数：float   1.1，1.2，3.3.......小数（正小数，负小数）

        布尔型：Ture or False , 正或假

          所有非0的数字为True
          所有非空的对象为True

        字节型：bytes， b'123',加小写b表示字节

        字符串：'word'字符串，包含了4个字符，用单引号，双引号，三个单引号或者三个双引号的                          形式表示

             字符串是一个序列，按顺序去存储
              序列是有下标的，从0开始， 0-》第一个位置
              变量[下标]: 下标一定是整数 正整数，0，负整数

                        内置的不可变的序列

        空类型：None

#None： 如果你在定义变量的时候，不知道这个变量是什么类型

data = None
print(data, type(data))

        复杂数据类型：

1.元组：

tuple: 元组
Built-in immutable sequence. 内置的不可变的序列
怎么去定义一个元组：
使用小括号()括起来，里边可以有多个元素，用逗号分隔
可以存储不同类型的数据

#小细节，逗号的用法
str_data1 = ("a")            #tuple_data1为字符串类型
tuple_data2 = ("a",)            #tuple_data2为元组类型




"""
当括号只有一个元素是，并且后面有逗号，其类型为元组类型，如果有很多元素是，最后加不加逗号都为元组类型
"""

        1.1元组的定义

                a.如果没有传参数，则返回一个空元组。

                                tuple():----->返回空元组（）；

                b.（可迭代的，序列就是可迭代的），元组中的每一个元素，对应是序列中的每一 个元素

tuple_data = tuple("abcd")

#因为元组和字符串一样都是可迭代的，元组也可以将元组中的元素用下标拿出来
#并且和字符串一样是不可变的序列，元素不能改变

print(tuple_data[0])
print(tuple_data[1])
print(tuple_data[-2])
print(tuple_data[-1])
# tuple_data[0] = "z"        #错误❌

          1.1.2元组的方法

1. count（）#统计元组中当前给定的元素出现的次数， count-->计数

        调用：

              元组名.count(给定的元素) 

                eg:

                        tuple_data = (1, 2, 3, 1, 2 )        #定义一个元组

                        print(tuple_data.count(1))        #统计元组中1出现的次数        输出为：2

2. index()  索引，下标                如果你给定的值在元组中不存在，会抛出一个错误，如果                                                         找到了的话就会返回第一次出现该值的下标。

        调用：

                同上。

        eg：

                  tuple_data = (1, 2, 3, 1, 2 )        #定义一个元组

                  print(tuple_data.index(1))        #返回第一次出现1的下标          输出为：0

        如果想输出第二个位置上的 1 ，请往下看：

        eg：

                tuple_data = (1, 2, 3, 1, 2 )        #定义一个元组

                print(tuple_data.index(1，1，4))       

                """

                index中的第一个参数1，表示我们想要元素的下标

                                   第二个参数1，表示寻找元素是的初始位置

                                    第三个参数4，表示寻找元素的结束位置

                   输出为：3

                """

        注意：元组并不是一定不可变。 当元组中有列表时，改变元组中列表的值，从而元组也改变了

tuple_data = (1, 2, 3, [4, 5, 6])        #定义一个元组
tuple_data[3][0] = 10                      #更改元组内列表的值
print(tuple_data)                          #输出：(1， 2， 3， [10, 5, 6])

1.2列表        list

        定义的格式：[元素1， 元素2， 元素3]        （列表用中括号括起来）

            1. 与元组不同就算括号里只有一个元素，且没有”，“它的类型还是列表 

            2..内置的可变的序列

                        可变：1.内容可变

                                    3.长度可变(可用append方法添加一个元素到列表的结尾)

                        eg：

                                list_data  = [1, 2, 3, 4]        定义一个列表

                                list_data.append(5)              #使用方法给列表添加元素

                                print（list_data）                #输出：[1, 2, 3, 4, 5]

                                list_data[0] = 10                    #将列表中下表为0的元素的值改为10

                                print(list_data)                       #输出：[10, 2, 3, 4, 5]

                        可以存储如果数据类型的数据（与元组一样）

            3.如果没有给参数，创建出来的就是空列表

            4.给定的参数必须是可迭代的（元组、字符串、列表）。

      1.2.1  list中的方法

1. append  同上
2. clear（）  : 移除列表中的所有元素
3. copy（）：浅拷贝
4. id（）     ：返回对象的标识（地址）       
5. count（）：计数。     用法与元组相同 
   1. extend（）：扩展列表                无返回值

                ​​​​list_data = [1, 2, 3, 4]                #定义一个列表

                list_data.extend("123")            #给列表扩展一个字符串

                print(list_data)                           #输出：[1, 2, 3, 4, '1', '2', '3']

     7.insert（）：插入     将元素插入到指定位置，并且指定位置后的元素全都向后 移一位

                ​​​​list_data = [1, 2, 3, 4]                #定义一个列表

                list_data.insert(2, 3)                #第一个参数“2”表示插入的位置的下标，

                                                                  #第二个参数“3”表示想要插入的元素。

                print(list_data)                         #输出为：[1, 2, 3, 4]

     8.pop()  :        往外弹出一个元素，并且元列表发生了改变。可在给定参数，表示要

                             弹出元素的下标。

                list_data = [1, 2, 3, 4]                #定义一个列表

                pop_data = list_data.pop()      #调用pop（）函数

                print(pop_data)                        #输出：4

                print(list_data)                        #输出：[1, 2, 3]

               pop_data1 = list_data.pop(1)  #将下表为1的元素弹出

                print(pop_data1)                        #输出：2

                 print(list_data)                        #输出：[1, 3]

       9.remove（）   移除        移除指定的元素（没有返回值）      

                                注意：移除元素后，该元素后的元素的位置都发生了改变。

      10.reverse        原地倒置

                  list_data = [1, 2, 3, 4]                #定义一个列表          

                  list_data.reverse()                     #调用reverse（）方法

                  print(list_data)                           #输出：[4, 3, 2, 1]

      11.sort()        排序

                  list_data = [1, 2, 3, 4]                #定义一个列表          

                  list_data.sort()                           #调用sort()方法

                  print(list_data)                           #输出：[1， 2， 3， 4]

               当然，还可以按与字母顺序相反的顺序排列列表元素，此时只需向sort（）方法传递参数 reverse = True即可

               

                  list_data = [1, 2, 3, 4]                            #定义一个列表          

                  list_data.sort(reverse = True)               #调用sort()方法

                  print(list_data)                                     #输出：[4, 3, 2, 1]

   12.len()    获取列表的长度

                 list_data = [1, 2, 3, 4]                            #定义一个列表   

                 print(len(list_data))                                          #输出：4

退出码：

0： 正常执行完成
1： 执行过程中遇到问题
-1：手动终止

变量的定义：

格式：  变量名 = 值 ==> variable name ==>value

在Python中，变量类似于一个标签，可以通过变量来访问所对应的值，变量的类型有值来决定

        (1)将7赋值给a，这样就成功创建了一个包含整数7的对象（a为变量名）;

        (2)打印a的值；

        (3)将a赋值给b，这相当于给刚刚创建的对象又贴上了标签b；

        (4)打印b的值；         

a = 7 
print(a)
b = a
print(b)

输出：

7
7

Process finished with exit code 0

查看变量属性的函数：

        print(variable name)  ；打印变量内容

        type(variable);       变量类型

        id(variable);     查看变量标识

输出：**

        print(type(variable name);

eg：

a = 7
print(a, type(a))
b = 99.9
print(b, type(b))
c = 'abc'
print(c, type(c))

输出

7 <class 'int'>
99.9 <class 'float'>
abc <class 'str'>

Process finished with exit code 0

变量名的定义：

    1.变量名只能包含以下字符：

        小写字母(a~z)

        大写字母(A~Z)

        数字(0~9)

        下划线( _ )

    2.数字不允许一数字开头。

        下面这些是不合法的：

                1

                1a

                1_

        下面这些是合法的：

                a

                a1

                a_b_c__95

                _ac

  3.不能用Python中的关键字作变量名