Python基本语法

一、程序和用户交互

Python中，使用input函数实现

input("这里写提示信息， 必须使用引号引起来")

二、变量

用户的输入可以使用一个变量来接收

s = input("请输入一个数字")

例：
In [1]: n = input("请输入一个数字：")
请输入一个数字：9

In [2]: n
Out[2]: '9'

1.变量命名规则：

①不要以单下划线和双下划线开头

②变量名不得使用标准库（内置）的模块或者第三方的模块名

③不要使用Python内置的关键字命名

In [3]: import keyword

In [4]: keyword.kwlist
Out[4]:
['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']

2.Python中变量的赋值过程：

        s = 'hello'

变量名s分配给hello这个对象；----Python中一切皆对象

hello这个对象会在内存中显先被创建，之后再把变量名s分配给这个对象。

对象时在右边先被创建或者获取，在此之后左边的变量名才会被绑定到对象上，就相当于为对象贴上了一个标签。

一个对象可以有多个标签或者名字。

例如：

In [5]: a = 1

In [6]: b = a

In [7]: a = 2

In [8]: print(b)
1

3.多元赋值

多元赋值：同时给多个变量进行赋值

In [9]: n1, n2 = 1, 4

In [10]: n1
Out[10]: 1

In [11]: n2
Out[11]: 4

In [12]: s1, s2 = '12'

In [13]: s1
Out[13]: '1'

In [14]: s2
Out[14]: '2'

In [15]: num, s = [10, 'hello']

In [16]: num
Out[16]: 10

In [17]: s
Out[17]: 'hello'

三、Python中的判断条件

In [18]: n = 10 #进行赋值

In [19]: n == 10 #等于
Out[19]: True    #条件为真，则返回True

In [20]: n != 10 #不等于
Out[20]: False    #条件为假，则返回False

In [21]: n > 10    #大于
Out[21]: False

In [22]: n < 10    #小于
Out[22]: False

In [23]: n >= 10    #大于等于
Out[23]: True

In [24]: n <= 10    #小于等于
Out[24]: True

例如·

In [30]: n = input("请输入一个数字：")
请输入一个数字：78

In [31]: n == 78
Out[31]: False


In [32]: type (n)
Out[32]: str

这里返回False，是因为数据类型 。

在编程中，数据是有类型之分的，input（）接收到的任何数据都会成为字符串类型（str）

四、数据类型

1.查看数据的类型——使用type

In [36]: type(10)
Out[36]: int

In [37]: type (n)
Out[37]: str

2.整型（int）

In [39]: type(0)
Out[39]: int

In [40]: type(-1)
Out[40]: int

3.浮点数（float）

带小数点的小数

In [41]: type(1.241)
Out[41]: float

In [42]: type(-24432531.2423)
Out[42]: float

4.布尔型（bool）

In [44]: type(True)
Out[44]: bool

In [45]: type(False)
Out[45]: bool

5.字符串（str）

引号引起来的都是字符串

In [46]: type('3124')
Out[46]: str

In [47]: type('hello')
Out[47]: str

6.二进制（bytes）

用b开头的字符串

In [48]: type(b'hello')
Out[48]: bytes

7.类型转换

①.转换为int

In [1]: int('10')
Out[1]: 10

In [2]: int(12.25)
Out[2]: 12

②.转换为float

In [3]: float(1)
Out[3]: 1.0

In [4]: float(0)
Out[4]: 0.0

③.转换为str

所有都能转换为字符串

In [1]: str(214)
Out[1]: '214'


In [2]: str(b'hello',encoding='utf-8')
Out[2]: 'hello'

二进制转换为字符串的时候，需要指定字符编码

④.转换为二进制

In [3]: bytes('羊羊', encoding=('utf-8'))
Out[3]: b'\xe7\xbe\x8a\xe7\xbe\x8a'

字符串转二进制的时候，需要指定字符编码

五、if语句

语法：

if 条件1:
    # 当条件1成立时执行这里的代码块
elif 条件2:
    # 当条件2成立时执行这里的代码块
elif 条件3:
    # 当条件3成立时执行这里的代码块
else:
    # 当以上条件都不成立时执行这里的代码块

In [10]: if 19 == 18:
    ...:     print("相等")
    ...:     print("猜对了")
    ...: elif 17 > 18:
    ...:     print("大了")
    ...: elif 19 <  18:
    ...:     print("小了")
    ...: else:
    ...:     print("以上条件都不满足")
    ...:
以上条件都不满足

六、循环

1.语法：

while 条件表达式：

        条件表达式为真，就执行这里的代码

七、Python程序执行

vim hello.py
#!/usr/bin/env python3
# file name hello.py

print("猜数游戏开始")

n = input("请输入一个数字")
n = int(n)

if n == 18:
    print("猜对了")
elif  n > 18:
    print("大了")
else:
    print("小了")


执行
[root@localhost python_code]# python3 hello.py
猜数游戏开始
请输入一个数字5
小了


[root@localhost python_code]# chmod +x hello.py
[root@localhost python_code]# ./hello.py
猜数游戏开始
请输入一个数字6
小了

八.函数的定义和调用

1.函数的定义

def 函数名():
"""函数的说明"""
    函数体

函数名的规则于变量名的规则一致

2.函数的调用

调用方式：

函数名()

## Python属于解释性语言，就是代码需要读一行，解释器解释一行；因此函数就是定义一个“变量”，必须先定义函数，才能调用函数。

3.示例

>>> def yy():
...     print("我是函数体，只在调用函数时，这里的代码才会被执行哦")
...
>>> yy()  # 正确调用函数
我是函数体，只在调用函数时，这里的代码才会被执行哦

[root@localhost ~]# vim test.py
#!/usr/bin/env python3

def guess_number():
    """输入一个数字，和13 比较大小"""
    print("猜数游戏开始")

    while True:
        n = input("请输入一个数字")

        # 如果输入空，就重新开始新一轮的循环
        if not n:
            continue

        # 如果输入 q 就是跳出循环
        if n == 'q':
            break

        n = int(n)

        if n == 13:
            print("猜对了")
        elif  n > 13:
            print("大了")
        else:
            print("小了")


# 调用函数
guess_number()

exit("退出程序..")

九、字符串

1.字符串的基本操作

In [1]: s1 = """hello
   ...: shark
   ...: """

In [2]: s2 = '''
   ...: hello world
   ...: '''

In [3]: s1
Out[3]: 'hello\nshark\n'

In [4]: s2
Out[4]: '\nhello world \n'

In [5]: print(s1)
hello
shark


In [6]: print(s2)

hello world


In [7]: a1 ='yyang'

In [8]: print(a1)
yyang

2.简单操作

①转义符\

In [9]: yy = 'this shirt doesn\'t fit me'

In [10]: print(yy)
this shirt doesn't fit me

In [11]: words = 'hello \nshark'

In [12]: print(words)
hello
shark

由于引号里面的字符串存在'防止和最外层的引号冲突，中间加转义符号\;

\n被转换为换行符；

②拼接+

In [13]: file_name = "成功的21个信念"

In [14]: suffix = '.txt'

In [16]: file_name = file_name + suffix

In [17]: file_name
Out[17]: '成功的21个信念.txt'

拼接只能字符串和字符串进行操作，不可以字符串和一个非字符串类型的对象相加

③复制*

In [20]: yy = "##$$&&"

In [21]: yy * 4
Out[21]: '##$$&&##$$&&##$$&&##$$&&'

3.取值和切片

取值

字符串是Python中的一个序列类型的数据结构——存放的数据是有序的

s1 = "shark"

序列类型的特特点

• 序列里的每一个数据被称为序列的一个元素
• 元素在序列里都是有个自己的位置，这个位置被称为索引或者叫偏移量（下标），从0开始，从左到右一次递增
• 序列中的每一个元素可以通过这个元素的索引来获取
• 获取到序列类型数据中的多个元素需要切片操作来获取

In [22]: s1 = "shark"

In [23]: s1[0]
Out[23]: 's'

In [24]: s1[-1]
Out[24]: 'k'

切片——获取多个元素

[start ： end ：step]

#start-起始索引号

#end-终止索引号

#step-可选步长

默认顺序：从左至右

##分片操作只包含起始索引位置的元素，不包含终止索引位置的元素

In [25]: s1 = "shark"

In [26]: s1[0:1]
Out[26]: 's'

In [27]: s1[0:3]
Out[27]: 'sha'

练习

In [28]: s1 = "shark"

#使用切片获取多个元素
In [29]: s1[0:3]
Out[29]: 'sha'

#起始和结尾的索引号可以省略
In [30]: s1[:3]
Out[30]: 'sha'

In [31]: s1[1:]
Out[31]: 'hark'

#索引可以使用负数
In [32]: s1[2:-1]
Out[32]: 'ar'

#默认切片是从左至右，索引号-1的右边没有值了就没获取到
In [33]: s1[-1:-3]
Out[33]: ''

步长

步长九十每隔几个数取几个的意思

步长是正数时，从左向右开始操作

步长是负数时，从右向左开始操作

In [34]: s2 = 'abcdefgh'

In [35]: s2[::2]
Out[35]: 'aceg'

In [36]: s2[::4]
Out[36]: 'ae'

In [37]: s2[::-3]
Out[37]: 'heb'

4.统计序列数据的长度

In [1]: s3 = "a \n\t"

In [2]: len(s3)
Out[2]: 4

In [3]: s4 = "a\n\t"

In [4]: len(s4)
Out[4]: 3

\n是一个换行符

\t是一个Tab健

5.in 成员判断

In [5]: line = 'size:8192MB'

In [6]: 'S' in line
Out[6]: False

In [7]: ':' in line
Out[7]: True


In [8]: 's' in line
Out[8]: True

In [9]: if 'size' in line:
   ...:     print(line)
   ...:
size:8192MB

In [10]: "" in "asd"
Out[10]: True

空字符串总是被视为任何其他字符串的子串，因此" "in "asd" 将返回True

6.strip()去除字符串两端的空白字符（空格、\t、\n）

In [11]: line1 = '     size:8192 MB'

In [12]: line1.strip()
Out[12]: 'size:8192 MB'

7.split()分割

默认使用空白字符作为分隔符（空格、\t、\n）-----------类似awk

In [16]: line2 = '    size : 8192 MB'

In [17]: line2.split()
Out[17]: ['size', ':', '8192', 'MB']

In [18]: s1 = '\tyy\n'

In [19]: s1.split()
Out[19]: ['yy']

指定分隔符

In [21]: line
Out[21]: 'size:8192MB'

In [22]: line.split(':')
Out[22]: ['size', '8192MB']

8.replace（）替换

In [27]: yy = 'yangyangwwx'

#将yang替换成空
In [28]: yy.replace('yang','')
Out[28]: 'wwx'

练习

In [23]: line = '　　<strong>10、命运在自己手里，而不是在别人的嘴里</strong></p>'

In [24]: line.strip()
Out[24]: '<strong>10、命运在自己手里，而不是在别人的嘴里</strong></p>'

In [25]: line.strip().replace('strong>', '')
Out[25]: '<10、命运在自己手里，而不是在别人的嘴里</</p>'

In [26]: line.strip().replace('strong>', '')[1:-6]
Out[26]: '10、命运在自己手里，而不是在别人的嘴里'

9.startswith(判断字符串以什么为开头

In [29]: line3 = 'Local'

In [30]: line3.startswith("L")
Out[30]: True

In [31]: line3.startswith("M")
Out[31]: False

10.endswith()判断字符串以什么为结尾

In [32]: line4 = '1024MB'

In [33]: line4.endswith('MB')
Out[33]: True

In [34]: line4.endswith('B')
Out[34]: True

In [35]: line4.endswith('M')
Out[35]: False

十、列表

1.列表特性

• 列表和字符串一样也是序列类型的数据
• 列表内的元素直接用英文的逗号隔开，元素是可变的，所以列表式可变的数据类型，而字符串不是
• 列表的元素可以是Python中的任何类型的数据对象
• 列表中的具有相同值的元素允许出现多次

2.创建列表 

In [36]: li = ['yy','ly']

In [37]: len(li)
Out[37]: 2

In [38]: list('hello')
Out[38]: ['h', 'e', 'l', 'l', 'o']

#嵌套列表
In [39]: li1 = [['one','two'],[1,2,3]]

In [40]: li1
Out[40]: [['one', 'two'], [1, 2, 3]]

3.列表的基本操作

3.1取值和就地修改

In [1]: l2 = ['insert', 'append', 'remove', 'pop', 'sort']

In [2]: l2 [0]
Out[2]: 'insert'

In [3]: l2 [-1]
Out[3]: 'sort'

3.2嵌套的列表取值

In [4]: l3 =[['one', 'two', 'three'],[1, 2, 3]]

In [5]: l3 [0][1]
Out[5]: 'two'

In [6]: l3[1][2]
Out[6]: 3

3.3就地修改

可以通过索引直接修改索引对应位置的数据

In [6]: l1 = ['yang' , '123', 1314]

In [7]: l1[0] = 'love'

In [8]: l1
Out[8]: ['love', '123', 1314]

In [9]: l1[-1] = 520

#负数变成替换
In [10]: l1
Out[10]: ['love', '123', 520]

In [11]:

3.4切片

参考字符串的切片方法即可

In [14]: line = 'size : 8192 MB\n'

In [15]: line.split('\n')
Out[15]: ['size : 8192 MB', '']

In [16]: l5 = line.split('\n')

#[:1]就是[0:1]代表的就是从从第一项到最后一项，最后一项取不到
In [17]: l5[:-1]
Out[17]: ['size : 8192 MB']

3.5列表必会方法

len()：可以统计列表类型的数据结构的长度。

In [24]: li = ['yang', '12213', 214314, 'yy']

In [25]: len(li)
Out[25]: 4

in：判断元素是否在列表中。【要对应里面元素的类型来判断】

In [30]: li = ['yang', '12213', 214314, 'yy']

In [31]: 'yang' in li
Out[31]: True

In [32]: 214314 in li
Out[32]: True

In [33]: '12213' in li
Out[33]: True

In [34]: 12213 in li
Out[34]: False

append()：向列表的最后位置，添加一个元素，只接收一个参数。

In [2]: li = ['www', 1213, '521']

In [3]: li.append(521)

In [4]: li
Out[4]: ['www', 1213, '521', 521]

In [5]:

insert（）：向原列表的指定位置插入一个元素，接收两个参数，第一个是索引号，第二个是要插入的元素。

In [5]: li
Out[5]: ['www', 1213, '521', 521]

In [6]: li.insert(0,12345)

In [7]: li
Out[7]: [12345, 'www', 1213, '521', 521]

remove（）:去除列表中某个指定的元素，没有返回值，并且假设多个相同的元素存在，每次只会移除排在最前面的那个元素。

In [8]: li
Out[8]: [12345, 'www', 1213, '521', 521]

In [9]: li.remove(521)

In [10]: li
Out[10]: [12345, 'www', 1213, '521']