第一讲python的基本语法
1输入语句 input
格式： 变量=input (“输入提示信息”）
功能： 从键盘上输入信息到变量中，可以强转为各种数据类型
案例：x=input(“您的个人基本信息”）
注意点： 只能接受一个信息
- 输出语句 print
- 格式： print （value，sep ,end=”
”)
- 功能：输出数据到屏幕上
选项说明：
1）value：用户要输出的内容 可以用多个逗号分隔
2）Sep：用于设置多个要输出数据之间的分隔符，默认为空格。
3)end:在所有信息输出后再输出的信息符号，默认为空格。
案例： print(12,34,56,78)
12 34 56 78
print(“1”,’23’,”34”,67,sep=”*”)
Print(“我喜欢葡萄红”,”学会python,数据分析我是高手”,sep=’999’,end=”$$”)
我喜欢葡萄红999学会python，数据分析我是高手$$
格式化：
格式print(“ 输出’占位符’信息”分隔符%数据集)
案例：
- 程序编辑换行问题
1) 换行符
2) 续行符
3) 将多行写成一行
4) Configure
案例：
Print(“开始我们的学习，这个时间有点累”）
Print(“开始我们的学习，
这个时间有点累”）
X=10;y=345;d=90;x1=’ffff’ ·
Print(“x=%d,y=%d,d=%d”,(x,y,d((
Print(x1)
4代码注释
1) 行注释 #ascascsa
2) 块注释 “csadas”
‘’’sds’’’
5 五个程序
例1根据圆的半径计算圆的周长和面积。
r= float(input("请输入半径"))
circumference = 2.0 * 3.14 * r
area = 3.14 * r * r
print ("圆的周长是: %.2f"% circumference)
print ("圆的面积是: %.2f"% area)
例2 摄氏温度转化为华氏温度。
a=float(input(‘请输入摄氏温度:‘))
c=a*9/5+32
print("摄氏温度{}转化为华氏温度为:{}".format(a,c))
例3 用三行print，完成以下信息的显示：
print("= "*50)
print("= 欢迎进入身份认证系统 V1.0")
print("= 1.登陆")
print("= 2.退出")
print("= 3.认证")
print("= 4.修改密码")
print("= "*50)
例4编写程序，从键盘获取信息，然后按照下面格式显示
name = input("请输入名字>>>")
qq = input("请输入qq>>>")
phone_num = input("请输入手机号>>>")
com_addr = input("请输入公司地址>>>")
print("="*30)
print("
姓名:",name)
print("
qq:",qq)
print("
phone_num",phone_num)
print("
com_addr",com_addr)
print("="*30)
例5关于python的一个彩蛋
Import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren‘t special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you‘re Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it‘s a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let‘s do more of those!
6.标识符和保留字
1）概念：用来定义变量名称，函数，类，模块的名称的字符串。
2）字符：0-9，a-z,A-Z,特殊符号
3）python标识符的使用规则
第一个字符必须是字符或下划线，并且字符之间不能有空格
Python字符区分大小写
Python3可以使用非ASCII的字符
保留字不能作为标识符使用
If python end print
4）命名的注意点：见其名便知其意 BookManage_one
变量
1）用标识符定义的名称成为变量
2）变量是用来保持数据的，数据是有类型，Int，float,double,bool,String
Python 的数据结构类型
Set(集合)，list(列表)，dictionary(字典),
Tuple（元组）
3）Python中的直接赋值，自动识别数据类型
函数：type（变量名）
功能：识别变量的数据类型
- python的基本语法
例2-1 python语句的缩进
a= input("请输入第一个数")
b= input("请输入第二个数")
if a>b:
print(‘a>b‘)
else:
print(‘b>a‘)
例2-2
Python的多行语句
- python的运算符
- 算术运算
+ ,- ,* ,/ ,%
//：整除，返回商的整数部分。
**：求幂/次方
案例：
3//2=1
2**3=8
A=7+8
Print（a）
A=15
- 赋值运算
=, +=, -=, *=, /=, //=, %=, **=
案例 a+=b == a=a+b
a//=b == a//b
a = 5
b = 3
a **= b
Print (a)
125
- 比较运算
<, <=, >, >=, ==, !=, is, is not
案例
Is ：判断两个标识符是否引用自一个对象
“==”判断两个对象是否相等
a = 5==6
Print(a)
b =”yes”==”yes”
Print(b)
False
True
- 逻辑运算
or, and, not,
案例：逻辑非运算符
x =True
y =not x
print(y)
z=False
print(not z)
运行结果:False
True
Python3菜鸟扩充
1.
标识符
- 第一个字符必须是字母表中字母或下划线 _ 。
- 标识符的其他的部分由字母、数字和下划线组成。
- 标识符对大小写敏感。
2.
数字(Number)类型
python中数字有四种类型：整数、布尔型、浮点数和复数。
- int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
- bool (布尔), 如 True。
- float (浮点数), 如 1.23、3E-2
- complex (复数), 如 1 + 2j、 1.1 + 2.2j
- python中单引号和双引号使用完全相同。
- 使用三引号(‘‘‘或""")可以指定一个多行字符串。
- 转义符 ‘‘
- 反斜杠可以用来转义，使用r可以让反斜杠不发生转义。。 如 r"this is a line with
" 则
会显示，并不是换行。
- 按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。
- 字符串可以用 + 运算符连接在一起，用 * 运算符重复。
- Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
- Python中的字符串不能改变。
- Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
- 字符串的截取的语法格式如下：变量[头下标:尾下标:步长]
3.字符串(String)
word = ‘字符串‘
sentence = "这是一个句子。"
paragraph = """这是一个段落，
可以由多行组成"""
实例(Python 3.0+)
#!/usr/bin/python3 str=‘Runoob‘ print(str) # 输出字符串 print(str[0:-1]) # 输出第一个到倒数第二个的所有字符 print(str[0]) # 输出字符串第一个字符 print(str[2:5]) # 输出从第三个开始到第五个的字符 print(str[2:]) # 输出从第三个开始的后的所有字符 print(str * 2) # 输出字符串两次 print(str + ‘你好‘) # 连接字符串 print(‘------------------------------‘) print(‘hello
runoob‘) # 使用反斜杠()+n转义特殊字符 print(r‘hello
runoob‘) # 在字符串前面添加一个 r，表示原始字符串，不会发生转义
这里的 r 指 raw，即 raw string。
输出结果为：
RunoobRunoo
R
noo
noobRunoobRunoobRunoob你好------------------------------
hello
runoob
hello
runoob
4.
实例(Python 3.0+)
#!/usr/bin/python3 input("
按下 enter 键后退出。")
以上代码中 ，"
"在结果输出前会输出两个新的空行。一旦用户按下 enter 键时，程序将退出。
5.
Print 输出
print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：
实例(Python 3.0+)
#!/usr/bin/python3 x="a" y="b" # 换行输出 print( x ) print( y ) print(‘---------‘) # 不换行输出 print( x, end=" " ) print( y, end=" " ) print()
以上实例执行结果为：
a
b---------
a b
6.标准数据类型
Python3 中有六个标准的数据类型：
- Number（数字）
- String（字符串）
- List（列表）
- Tuple（元组）
- Set（集合）
- Dictionary（字典）
Python3 的六个标准数据类型中：
- 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
- 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
7.
当你指定一个值时，Number 对象就会被创建：
var1 = 1
var2 = 10
您也可以使用del语句删除一些对象引用。
del语句的语法是：
del var1[,var2[,var3[....,varN]]]
您可以通过使用del语句删除单个或多个对象。例如：
del vardel var_a, var_b
8.
String（字符串）
Python中的字符串用单引号 ‘ 或双引号 " 括起来，同时使用反斜杠 转义特殊字符。
字符串的截取的语法格式如下：
变量[头下标:尾下标]
索引值以 0 为开始值，-1 为从末尾的开始位置。
加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，紧跟的数字为复制的次数。实例如下：
实例
#!/usr/bin/python3 str = ‘Runoob‘ print (str) # 输出字符串 print (str[0:-1]) # 输出第一个到倒数第二个的所有字符 print (str[0]) # 输出字符串第一个字符 print (str[2:5]) # 输出从第三个开始到第五个的字符 print (str[2:]) # 输出从第三个开始的后的所有字符 print (str * 2) # 输出字符串两次 print (str + "TEST") # 连接字符串
执行以上程序会输出如下结果：
RunoobRunoo
R
noo
noobRunoobRunoobRunoobTEST
Python 使用反斜杠()转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：
>>> print(‘Ru
oob‘)Ru
oob>>> print(r‘Ru
oob‘)Ru
oob>>>
另外，反斜杠()可以作为续行符，表示下一行是上一行的延续。也可以使用 """...""" 或者 ‘‘‘...‘‘‘ 跨越多行。
注意，Python 没有单独的字符类型，一个字符就是长度为1的字符串。
实例
>>>word = ‘Python‘ >>> print(word[0], word[5]) P n >>> print(word[-1], word[-6]) n P
与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = ‘m‘会导致错误。
注意：
- 1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
- 2、字符串可以用+运算符连接在一起，用*运算符重复。
- 3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
- 4、Python中的字符串不能改变。
- 9.
Tuple（元组）
元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。
元组中的元素类型也可以不相同
实例
#!/usr/bin/python3 tuple = ( ‘abcd‘, 786 , 2.23, ‘runoob‘, 70.2 ) tinytuple = (123, ‘runoob‘) print (tuple) # 输出完整元组 print (tuple[0]) # 输出元组的第一个元素 print (tuple[1:3]) # 输出从第二个元素开始到第三个元素 print (tuple[2:]) # 输出从第三个元素开始的所有元素 print (tinytuple * 2) # 输出两次元组 print (tuple + tinytuple) # 连接元组
以上实例输出结果：
(‘abcd‘, 786, 2.23, ‘runoob‘, 70.2)
abcd(786, 2.23)(2.23, ‘runoob‘, 70.2)(123, ‘runoob‘, 123, ‘runoob‘)(‘abcd‘, 786, 2.23, ‘runoob‘, 70.2, 123, ‘runoob‘)
元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取（看上面，这里不再赘述）。
其实，可以把字符串看作一种特殊的元组。
实例
>>>tup = (1, 2, 3, 4, 5, 6) >>> print(tup[0]) 1 >>> print(tup[1:5]) (2, 3, 4, 5) >>> tup[0] = 11 # 修改元组元素的操作是非法的 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: ‘tuple‘ object does not support item assignment >>>
虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：
tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
string、list 和 tuple 都属于 sequence（序列）。
注意：
- 1、与字符串一样，元组的元素不能修改。
- 2、元组也可以被索引和切片，方法一样。
- 3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
- 4、元组也可以使用+操作符进行拼接。
10.
Set（集合）
集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
创建格式：
parame = {value01,value02,...}或者set(value)
实例
#!/usr/bin/python3 student = {‘Tom‘, ‘Jim‘, ‘Mary‘, ‘Tom‘, ‘Jack‘, ‘Rose‘} print(student) # 输出集合，重复的元素被自动去掉 # 成员测试 if ‘Rose‘ in student : print(‘Rose 在集合中‘) else : print(‘Rose 不在集合中‘) # set可以进行集合运算 a = set(‘abracadabra‘) b = set(‘alacazam‘) print(a) print(a - b) # a 和 b 的差集 print(a | b) # a 和 b 的并集 print(a & b) # a 和 b 的交集 print(a ^ b) # a 和 b 中不同时存在的元素
以上实例输出结果：
{‘Mary‘, ‘Jim‘, ‘Rose‘, ‘Jack‘, ‘Tom‘}Rose 在集合中{‘b‘, ‘a‘, ‘c‘, ‘r‘, ‘d‘}{‘b‘, ‘d‘, ‘r‘}{‘l‘, ‘r‘, ‘a‘, ‘c‘, ‘z‘, ‘m‘, ‘b‘, ‘d‘}{‘a‘, ‘c‘}{‘l‘, ‘r‘, ‘z‘, ‘m‘, ‘b‘, ‘d‘}
11.
Dictionary（字典）
字典（dictionary）是Python中另一个非常有用的内置数据类型。
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的。
实例
#!/usr/bin/python3 dict = {} dict[‘one‘] = "1 - 菜鸟教程" dict[2] = "2 - 菜鸟工具" tinydict = {‘name‘: ‘runoob‘,‘code‘:1, ‘site‘: ‘www.runoob.com‘} print (dict[‘one‘]) # 输出键为 ‘one‘ 的值 print (dict[2]) # 输出键为 2 的值 print (tinydict) # 输出完整的字典 print (tinydict.keys()) # 输出所有键 print (tinydict.values()) # 输出所有值
以上实例输出结果：
1 - 菜鸟教程2 - 菜鸟工具{‘name‘: ‘runoob‘, ‘code‘: 1, ‘site‘: ‘www.runoob.com‘}
dict_keys([‘name‘, ‘code‘, ‘site‘])
dict_values([‘runoob‘, 1, ‘www.runoob.com‘])
构造函数 dict() 可以直接从键值对序列中构建字典如下：
实例
>>>dict([(‘Runoob‘, 1), (‘Google‘, 2), (‘Taobao‘, 3)]) {‘Taobao‘: 3, ‘Runoob‘: 1, ‘Google‘: 2} >>> {x: x**2 for x in (2, 4, 6)} {2: 4, 4: 16, 6: 36} >>> dict(Runoob=1, Google=2, Taobao=3) {‘Runoob‘: 1, ‘Google‘: 2, ‘Taobao‘: 3}
另外，字典类型也有一些内置的函数，例如clear()、keys()、values()等。
注意：
- 1、字典是一种映射类型，它的元素是键值对。
- 2、字典的关键字必须为不可变类型，且不能重复。
- 3、创建空字典使用 { }。
12.
Python数据类型转换
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。
13.
Python运算符优先级
以下表格列出了从最高到最低优先级的所有运算符：
|
运算符
|
描述
|
|
**
|
指数 (最高优先级)
|
|
~ + -
|
按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
|
|
* / % //
|
乘，除，取模和取整除
|
|
+ -
|
加法减法
|
|
>> <<
|
右移，左移运算符
|
|
&
|
位 ‘AND‘
|
|
^ |
|
位运算符
|
|
<= < > >=
|
比较运算符
|
|
<> == !=
|
等于运算符
|
|
= %= /= //= -= += *= **=
|
赋值运算符
|
|
is is not
|
身份运算符
|
|
in not in
|
成员运算符
|
|
not and or
|
逻辑运算符
|
以下实例演示了Python所有运算符优先级的操作：
实例(Python 3.0+)
#!/usr/bin/python3 a = 20 b = 10 c = 15 d = 5 e = 0 e = (a + b) * c / d #( 30 * 15 ) / 5 print ("(a + b) * c / d 运算结果为：", e) e = ((a + b) * c) / d # (30 * 15 ) / 5 print ("((a + b) * c) / d 运算结果为：", e) e = (a + b) * (c / d); # (30) * (15/5) print ("(a + b) * (c / d) 运算结果为：", e) e = a + (b * c) / d; # 20 + (150/5) print ("a + (b * c) / d 运算结果为：", e)
以上实例输出结果：
(a + b) * c / d 运算结果为： 90.0((a + b) * c) / d 运算结果为： 90.0(a + b) * (c / d) 运算结果为： 90.0
a + (b * c) / d 运算结果为： 50.0
8.运算符
8.1 算术运算符
假定 a=30, b=50
|
运算符
|
描述
|
案例
|
|
+
|
加：将两数相加
|
A+b=82
|
|
-
|
减：将两数相减
|
A-b=-20
|
|
*
|
乘：将两数相除
|
A*b=0.6
|
|
/
|
除：将两数相除
|
A/b=0.6
|
|
%
|
求余：将两数相除，求余数
|
A%b=30
|
案例
x=10
y=12
z=30
#整除运算
d=z//x
d1=z//y
print("d=%d"%d)
print("d1=%d"%d1)
#幂运算
print("x^z=%d"%(x**z))
#求模运算
e=x%y
print("x%y=",e)
8.2比较运算符
A=30 b=50
|
运算符
|
描述
|
案例
|
|
==
|
等于
|
(1==2)false
|
|
！=
|
不等于
|
(1!=2)true
|
|
>
|
大于:a>b返回a是否大于b
|
A>b false
|
|
<
|
小于:a<b返回a是否小于b
|
A<b true
|
|
>=
|
大于等于:a>=b返回a是否大于等于b
|
A>= false
|
|
<=
|
小于等于:a<=b返回a是否小于等于b
|
A<= false
|
8.3赋值运算符
假定a
|
运算符
|
描述
|
案例
|
|
=
|
等于：简单赋值运算
|
S=34
|
|
+=
|
加等于：加法赋值运算
|
A+=b
A=80 b=50
|
|
-=
|
减等于：加法赋值运算
|
A-=b
A=-20 b=50
|
|
*=
|
乘等于：乘法赋值运算
|
a*=b
A=1500,b=50
|
|
/=
|
除等于：除法赋值运算
|
|
|
%=
|
模等于：模赋值运算
|
|
|
//=
|
整除等于：整除赋值运算
|
|
|
**=
|
幂等于：幂赋值运算
|
|
案例：
8.4逻辑运算符
假定
|
运算符
|
功能说明
|
案例
|
|
And
|
x
|
1
|
1
|
0
|
0
|
|
|
y
|
1
|
0
|
1
|
0
|
|
结果
|
1
|
0
|
0
|
0
|
|
|
And:两边的结果都为真时，整个表达式的结果才为真。
Or：两边的结果都为假时，整个表达式的结果才为假。
如果有一个为真，整个表达式的结果为真。
Not：你真我假，我假你真。
8.5位运算符
|
运算符
|
描述
|
案例
|
|
&
|
位与：参与运算的两值，如果两个相应位都是1，则这个位的结果为1，否则为0.
|
3&2=2
00000011
00000010=
00000010
|
|
|
|
位或：参与运算的两值，如果两个相应位有一个是1，则这个位的结果为1，否则为0.
|
3|2=3
|
|
^
|
位异或：当两个对应的二进制位相异时，结果为1，否则为0
|
6^9=15
00000110
00001001
|
|
~
|
按位取反：我真你假，你真我假
|
|
|
<<
|
位左移:向左移动二进制位
|
2<<2=8
00000010
|
|
>>
|
位右移：向右移动二进制位
|
34>>3=4
|
8.6成员运算符
|
运算符
|
描述
|
案例
|
|
In
|
在：判断给定的数据是否是某个范围的成员
|
|
|
Not in
|
不在：判断给定的数据是否不是某个范围的成员
|
|
a=‘电视机‘
b=‘电视剧‘
c=[‘手机‘,‘电脑‘,‘电视机‘,‘冰箱‘]
print(c)
print(a)
print(b)
if(a in c):
print("我是你的成员")
else:
print("我不是你的成员")
if(b in c):
print("我是你的成员")
else:
print("我不是你的成员")
if(a not in c):
print("我是你的成员")
else:
print("我不是你的成员")
if(b not in c):
print("我是你的成员")
else:
print("我不是你的成员")
8.7身份运算符
|
运算符
|
描述
|
案例
|
|
Is
|
判断两个标识符是否是同一个对象的引用
|
|
|
Not is
|
判断两个标识符是否不是同一个对象的引用
|
|
引用：就是小名
8.8运算符的优先级
- () [] {}
- Object
- Object[i]
- +x,-x,~x
- X**y
- X*y,x%y,x/y
- X+y,x-y
- X<<y,x>>y
- X&y
- X^y
- X|y
- < <= > >= != <> is not is
- Not
- And
- Or lambda
以上是关于Python基础入门一的主要内容，如果未能解决你的问题，请参考以下文章
Python基础入门一
Python入门基础学习一
如何入门爬虫（基础篇）
如何入门爬虫（基础篇）
Python入门基础学习详解二
Python入门基础学习详解二