Python基础语法

• 基本语法

1. 注释

Python中的注释以 # 开头

# 第一个注释
print("Hello, Python!")  # 第二个注释

# 号右边的文字都会被当作说明文字，而不是真正要执行的程序。

# 号后面建议先添加一个空格，然后再编辑相应的说明文字

如果在代码后面添加注释，注释和代码之间至少要有两个空格。

 

还有一种独一无二的注释方式，那就是文档字符串。

       def find_all(self):

              """Return all items."""

              return self.find ('all')  

1. 行与缩进

# 行与缩进

if True:

   print("True")

else:

   print("False")

 

最好使用4个空格进行悬挂式缩进，并且同一个代码块的语句，

必须含有相同的缩进空格数。

 

注意：

        在Python中使用缩进时，绝对不要使用Tab，也不要Tab和空格混用。

 

1. 语句换行

# 语句换行 每行代码长度不要超过80个字符。对于过长代码可在语句外加一对圆括号，将其进行换行显示

string = ("Python是一种面向对象、解释型计算机程序设计语言，"

          "Guido van Rossum 于1989年底发明。"

          "第一个公开发行版本发行于1991年。"

          "Python源代码同样遵循 GPL (GNU General Public License)协议。")

需要注意的是：

    在[]、{}、()中包含的多行语句会进行隐式连接，无需再使用圆括号进行换行。

total = ['one', 'two', 'three', 'four', 'five']

 

• 变量和数据类型

1. 变量和赋值

num_one = 100

num_two = 87

result = num_one + num_two

print(result)

 

1. 变量的类型

1. 数字类型

包含整型、浮点型和复数类型，具体如下：

 

整型：0101     83   -239      0x80      88743743754

浮点型：3.1415             4.2E-10         -2.34E-19

复数类型：3.12+1.23j           -1.23-98j

 

1. 布尔类型

特殊的整型，它的值只有两个，分别是True和False。

如果将布尔值进行数值运算，True会被当作整型1，False会被当作整型0。

 

1. 字符串类型

Python中的字符串被定义为一个字符集合，它被引号所包含，引号可以是单引号、双引号或者三引号（三个连续的单引号或者双引号）。

字符串具有索引规则，第1个字符的索引是0，第1个字符的索引是1，以此类推。

string_one = 'Python1'

string_two = "Python2"

string_three = '''Python3'''

 

1. 列表和元组类型

可以将列表和元组当作是普通的“数组”，它们可以保存任意数量的任意类型的值，这些值称作元素。

列表中的元素使用中括号[]包含，元素的个数和值是可以随意修改的。

而元组中的元素使用小括号（）包含，元素不可以修改。

list_name = [1, 2, 'hello']  # 这是一个列表

tuple_name = (1, 2, 'hello')  # 这是一个元组

 

1. 字典类型

字典是Python中的映射数据类型，由键-值对组成。字典可以存储不同类型的元素，元素使用大括号{}来包含。

通常情况下，字典的键会以字符串或者数值的形式来表示，而值可以是任意类型。

              # 这是一个字典

              dict_name = {"name":"zhangsan", "age":18}   

                           

                            上述变量dict_name是一个字典类型，它存储了数据，

              第1个元素的键为name，值为zhangsan，

第2个元素的键为age，值为18

                           

在Python中，只要定义了一个变量，并且该变量存储了数据，那么变量的数据类型就已经确定了。这是因为系统会自动辨别变量的数据类型。

                           

number = 5.2

type(number)

>>> number=5.2

>>> type(number)

<class 'float'>

>>>

 

1. 集合类型

 

集合（set）是一个无序的不重复元素序列。

可以使用大括号 { } 或者 set() 函数创建集合，

注意：创建一个空集合必须用 set() 而不是 { }，

因为 { } 是用来创建一个空字典

>>> basket={'apple','orange','apple','banana','apple','watermelon'}

>>> basket

{'orange', 'banana', 'apple', 'watermelon'}

>>> 'orange' in basket

True

>>> 'abc' in basket

False

>>>



# 下面展示两个集合间的运算

>>> a=set('abcaradabra')

>>> b=set('acalazma')

>>> a

{'d', 'c', 'r', 'a', 'b'}

>>> b

{'c', 'l', 'z', 'm', 'a'}

>>> a-b                        # 集合a中包含而集合b中不包含的元素

{'r', 'b', 'd'}

>>> a|b                         # 集合a或b中包含的所有元素

{'d', 'c', 'r', 'l', 'z', 'm', 'a', 'b'}

>>> a&b                       # 集合a和b中都包含了的元素

{'c', 'a'}

>>> a^b                        # 不同时包含于a和b的元素

{'d', 'z', 'r', 'm', 'b', 'l'}

>>>



>>> test_set=set('AAA','BBB','CCC')

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: set expected at most 1 arguments, got 3

>>> test_set=set(('AAA','BBB','CCC'))

>>> test_set

{'CCC', 'AAA', 'BBB'}

>>> test_set.add('DDD')               # 添加元素

>>> test_set

{'CCC', 'AAA', 'DDD', 'BBB'}

>>> test_set.update({1,3})            # 添加元素

>>> test_set

{'AAA', 1, 3, 'DDD', 'CCC', 'BBB'}

>>> test_set.update([1,4],[5,6])     # 添加元素

>>> test_set

{'AAA', 1, 3, 4, 5, 'DDD', 6, 'CCC', 'BBB'}

>>>



>>> test_set.remove(4)            # 移除元素

>>> test_set

{'AAA', 1, 3, 5, 'DDD', 6, 'CCC', 'BBB'}

>>>

>>> test_set.remove('BBB')       # 移除元素

>>> test_set

{'AAA', 1, 3, 5, 'DDD', 6, 'CCC'}

>>>



>>> test_set.pop()             #随机删除集合中的一个元素

'AAA'

>>>

>>> test_set

{1, 3, 5, 'DDD', 6, 'CCC'}

>>>

>>> len(test_set)               #计算集合元素个数

6

>>> 3 in test_set               #判断元素是否在集合中

True

>>> 30 in test_set             #判断元素是否在集合中

False

>>>

>>> test_set.clear()           #清空集合

>>> test_set

set()

>>>

 

• 标识符和关键字

1. 标识符

1. 由字母、下划线和数字组成，且不能以数字开头。
2. 区分大小写。
3. 标识符不能使用关键字。
4. 规范：

1）见名之意；2）类名使用大写字母开头，模块名用小写加下划线方式

1. 关键字

>>> help()

                    

help> keywords

 

Here is a list of the Python keywords.  Enter any keyword to get more help.

 

False               def                 if                  raise

None                del                 import              return

True                elif                in                  try

and                 else                is                  while

as                  except              lambda              with

assert              finally             nonlocal            yield

break               for                 not

class               from                or

continue            global              pass

 

• 简单数值类型

1. 整型

整数类型简称整型，它用于表示整数，十进制、二进制（以0B或者0b开头）、八进制（以数字0开头）和十六进制（以0x或者0X开头）

>>> a = 0b10100

>>> type(a)

<class 'int'>

>>> a

20

>>> a = 0b11100

>>> type(a)

<class 'int'>

>>> a

28

>>> a = 1011

>>> a

1011

>>> a = 0b1011

>>> a

11

>>> a = 0b0101

>>> a

5

>>> a = 0b0110

>>> a

6

>>> bin(20)

'0b10100'

>>> oct(20)

'0o24'

>>> hex(20)

'0x14'

>>>

>>> a=100000000000*10000000000

>>> a

1000000000000000000000

>>> type(a)

<class 'int'>

>>>

 

 

1. 浮点型

遵循IEEE754双精度标准，每个浮点数占8个字节，

能表示的范围是-1.79E+308 ~ +1.79E+308

>>> 1.2e5

120000.0



>>> -1.8e308

-inf

>>> 1.8e308

inf

>>>

 

1. 布尔类型

只有两个取值：True和False，分别对应整型的0和1。

可用于布尔测试（如用在if、while中）

 

以下对象的布尔值都是False：

1. None
2. False（布尔值）
3. 0（整型0）
4. 0L（长整型0）
5. 0.0（浮点型0）
6. 0.0+0.0j（复数0）
7. “”（空字符串）
8. []（空列表）
9. ()（空元组）
10. {}（空字典）

 

1. 复数类型

实部和虚部构成，都是浮点型

>>> a=1+2j

>>> a

(1+2j)

>>> a.real

1.0

>>> a.imag

2.0

>>> type(a.real)

<class 'float'>

>>> type(a.imag)

<class 'float'>

>>>

1. 数字类型转换

>>> a=1.2

>>> int(a)

1

>>> b=2

>>> float(b)

2.0

>>> complex(3,4)

(3+4j)

>>>

>>> complex(3.6)

(3.6+0j)

>>>

• 运算符

1. 算术运算符

 

a = 20

b = 10

c = 0



# 加法运算

c = a + b

print("1--c的值为：", c)



# 减法运算

c = a - b

print("2--c的值为：", c)



# 乘法运算

c = a * b

print("3--c的值为：", c)



# 除法运算

c = a / b

print("4--c的值为：", c)



# 取余运算

c = a % b

print("5--c的值为：", c)



# 取整除运算

c = a // b

print("6--c的值为：", c)



# 修改变量 a、b、c

a = 2

b = 3

c = a ** b  # 幂的运算

print("7--c的值为：", c)

 

 

1. 赋值运算符  =

>>> number=1

>>> number

1

>>> x=y=z=1

>>> x

1

>>> y

1

>>> z

1

>>> a,b = 1,2

>>> a

1

>>> b

2

>>>

注：Python中不支持C语言中的自增（++）和自减（--）运算符

 

1. 复合赋值运算符

a = 20

b = 10

c = 0

# 加法赋值运算

c += a

print("1---c的值为：", c)

# 乘法赋值运算

c *= a

print("3---c的值为：", c)

# 除法运算

c /= a

print("4---c的值为：", c)

# 先修改变量c的值，然后进行取余赋值运算

c = 2

c %= a

print("5---c的值为：", c)

# 先修改变量 a和c的值，然后进行幂赋值运算

a = 2

c = 3

c **= a

print("6---c的值为：", c)

# 取整除赋值运算

c //= a

print("7---c的值为：", c)

 

 

1. 比较运算符

a = 20

b = 10

c = 0

# 比较 a 和 b 的值是否相等

if (a == b):

    print("1——a等于b")

else:

    print("1——a不等于b")

# 比较 a 和 b 的值是否不相等

if (a != b):

    print("2——a不等于b")

else:

    print("2——a等于b")

# 比较 a 是否小于 b

if (a < b):

    print("3——a小于b")

else:

    print("3——a大于等于b")

# 比较 a 是否大于 b

if (a > b):

    print("4——a大于b")

else:

    print("5——a小于等于b")

# 修改变量 a 和 b 的值

a = 5

b = 20

# 比较 a 是否小于等于 b

if (a <= b):

    print("5——a小于等于b")

else:

    print("5——a大于b")

# 比较 b 是否大于等于 a

if (b >= a):

    print("6——b大于等于a")

else:

    print("6——b小于a")

 

 

1. 逻辑运算符

# 逻辑运算符

a = 20

b = 10

# 判断 a and b  布尔“与”。若a为真，继续计算b，表达式结果为b的值；若a为假，无需计算b，表达式结果为a的值

if a and b:

    print("1---变量a 和 b 都为 true")

else:

    print("1---变量a 和 b 有一个不为 true")

# 判断 a or b  布尔“或”。若a为真，无需计算b，表达式结果为a的值；若a为假，继续计算b，表达式结果为b的值

if a or b:

    print("2---变量a 和 b 都为 true，或其中一个变量为 true")

else:

    print("2---变量a 和 b 都不为 true")

# 修改变量 a 的值

a = 0

if a and b:

    print("3---变量a 和 b 都为 true")

else:

    print("3---变量a 和 b 有一个不为 true")

if a or b:

    print("4---变量a 和 b 都为 true，或其中一个变量为 true")

else:

    print("4---变量a 和 b 都不为 true")

# 判断not(a and b)

if not a and b:

    print("5---变量a 和 b 都为 false，或其中一个变量为 false")

else:

    print("5---变量a 和 b 都为 true")

 

 

1. 成员运算符

# 成员运算符

a = 20

b = 10

list_demo = [1,2,3,4,5]

# 判断变量a 是否在给定的列表list_demo中

if a in list_demo:

    print("1---变量a 在给定的列表 list_demo 中")

else:

    print("1---变量a 不在给定的列表 list_demo 中")

# 判断变量b 是否在给定的列表list_demo中

if b not in list_demo:

    print("2---变量b 不在给定的列表 list_demo 中")

else:

    print("2---变量b 在给定的列表 list_demo 中")

# 修改变量 a 的值

a = 2

if a in list_demo:

    print("3---变量a 在给定的列表 list_demo 中")

else:

    print("3---变量a 不在给定的列表 list_demo 中")

 

 

• 位运算

>>> a =6

>>> a

6

>>> bin(a << 2)                 #左移

'0b11000'

>>> a = 9

>>> bin(a << 2)                 #左移

'0b100100'

>>>

>>> a = 9

>>> a

9

>>> bin(a)                 

'0b1001'

>>> bin(a << 2)                 #左移

'0b100100'

>>> bin(a << 4)                 #左移

'0b10010000'

>>> bin(a << 6)                 #按位左移

'0b1001000000'

>>>



>>> a = 8

>>> bin(a)

'0b1000'

>>> bin(a >> 1)                        #右移

'0b100'

>>> a

8

>>> bin(a >> 2)                        #右移

'0b10'

>>> bin(a >> 3)                        #右移

'0b1'

>>> bin(a >> 4)                        #右移

'0b0'

>>> bin(a >> 5)                        #按位右移

'0b0'

>>>



>>> a = 9

>>> b = 3

>>> a & b                                 #按位与

1

>>> bin(a&b)

'0b1'

>>>

>>> c = 7

>>> d = 5

>>> c & d

5

>>> bin(c & d)                   #按位与

'0b101'

>>> e = 6

>>> c & e

6

>>> bin(c & e)                   #按位与

'0b110'

>>>

>>> a = 6

>>> b = 5

>>> bin(a | b)                     #按位或

'0b111'

>>>

>>> a = 8

>>> b = 3

>>> bin(a | b)                     #按位或

'0b1011'



>>> a = 8

>>> b = 3

>>> bin(a)

'0b1000'

>>> bin(b)

'0b11'

>>> bin(a | b)              #按位或

'0b1011'

>>> a = 6

>>> b = 5

>>> bin(a)

'0b110'

>>> bin(b)

'0b101'

>>> bin(a | b)              #按位或

'0b111'

>>>

>>> a = 8

>>> b = 4

>>> bin(a)

'0b1000'

>>> bin(b)

'0b100'

>>> bin(a | b)              #按位或

'0b1100'



>>> bin(a ^ b)            #按位异或

'0b1100'

>>>



>>> a = 9

>>> ~a

-10

>>> bin(a)

'0b1001'

>>> bin(~a)                #按位取反

'-0b1010'

>>>

• 运算符优先级

 

a = 20
b = 10
c = 15
d = 5
e = 0
e = (a + b) * c / d
print("e = (a + b) * c / d 运算结果为：", e)
e = ((a + b) * c) / d
print("e = ((a + b) * c) / d 运算结果为：", e)
e = (a + b) * (c / d)
print("e = (a + b) * (c / d) 运算结果为：", e)
e = a + (b * c) / d
print("e = a + (b * c) / d 运算结果为：", e)

 

• 练习题

 

一、填空题

1、在Python中，int表示的数据类型是整型。

2、布尔类型的值包括True和False。

3、Python的浮点数占8个字节。

4、如果要在计算机中表示浮点数1.2×10^5

 ，则表示方法为1.2e5。

5、00001000>>2的结果是00000010。

6、若a=20，那么bin(a)的值为0b10100。

7、如果想测试变量的类型，可以使用 type() 来实现。

8、若a=1，b=2，那么(a or b)的值为1。

9、若a=10，b=20，那么(a and b)结果为20。

10、4.34E5表示的是4.34×10^5。

 

二、判断题

Python使用符号#表示单行注释。(√)

标识符可以以数字开头。(×)

type()方法可以查看变量的数据类型。(√)

Python中的代码块使用缩进来表示。(√)

Python中的多行语句可以使用反斜杠来实现。(×)

Python中标识符不区分大小写。(×)

Python中的标识符不能使用关键字。(√)

使用help()命令可以进入帮助系统。(√)

Python中的成员运算符用于判断制定序列中是否包含某个值。(√)

比较运算符用于比较两个数，其返回的结果智能是True或False。(√)

 

三、选择题

1、下列选项中，(D)的布尔值不是Flase。

A.None

B.0

C.()

D.1

 

2、假设a=9，b=2，那么下列运算中，错误的是(D)。

A.a+b的值是11

B.a//b的值是4

C.a%b的值是1

D.a**b的值是18

 

3、下列标识符中，合法的是(AD)。

A.helloWorld

B.2ndObj

C.hello#world

D._helloworld

 

4、下列符号中，表示Python中单行注释的是(A)。

A.#

B.//

C.<!-- -->

D."“"

 

5、下列选项中，符合Python命名规范的标识符是(C)。

A.user-Passwd

B.if

C._name

D.setup.exe

 

下列选项中，Python不支持的数据类型有(B)。

A.int

B.char

C.float

D.dicitionary

 

下列表达式中，返回 True 的是(B)。

A.a=2 b=2 a=b

B.3>2>1

C.True and False

D.2!=2

 

下列语句中，哪个在 Python 中是非法的?(B)。

A.x = y = z = 1

B.x = (y = z + 1)

C.x, y = y, x

D.x += y

 

下列关于 Python 中的复数，说法错误的是(C)。

A.表示复数的语法是 real + image j

B.实部和虚部都是浮点数

C.虚部必须后缀 j，且必须是小写

D.一个复数必须有表示虚部的实数和 j

 

下列选项中，幂运算的符号为(D)。

A.*

B.++

C.%

D.**

 

四、简答题

简述Python中标识符的命名规则。

•标识符由字母、下划线和数字组成，且数字不能开头。

•python中的标识符是区分大小写的。

•python中的标识符不能使用关键字。

 

简述Python中的数字类型。

int(整型)、long(长整型)、float(浮点数)、complex(复数)

五、程序题

1、输入直角三角形的两个直角边的长度a、b，求斜边c的长度。

2、编写一个程序，用于实现两个数的交换。