python入门基础

     这里基本说的语法和代码都是基于python3来说的。

 

•       python代码运行
  （1）首先安装python3，配置环境变量。若安装成功后，cmd命令里输入python，就能进入python的交互式命令。安装好了，就可以通过命令行形式执行python脚本
  （2）python的编辑器推荐的有sublime和pycharm。
•     pycharm
   (1)pycharm可以建立项目，项目里创建py文件，针对文件可以根据自己的需要运行不同版本的python（比如python2.7、python3.5)。
  设置方法：file-settings——project:XX—project Interpreter

 

 

              (2)pycharm 常用的快捷键：代码注释——选择多行+ctrl+/        
                                                                代码格式化：ctrl+A ctrl+Alt+L    
                                                                自动导入模块：Alt +回车键Enter（光标放在模块名称上）

                                                               左侧project边上的小齿轮，选择show Members,可查看到文件里包含的函数方法

                                                               为了方便模块导入，需要做的操作：选择目录，右击——选择Mark Directory As——Sources Root 。若目录变蓝，则表示操作成功。

 

• 引号
  python中定义变量的时候字符串都用用引号括起来，单引号和双引号没有区别，用啥都行，如果说这个字符串里面有单引号的话，那你外面就用双引号，里面有双引号的话，外面就用单引号，如果既有单又有双，那么用三引号，三引号也可以多行注释代码，单行注释，使用#。
  

 

• 变量
  （1）定义变量不需要指定数据类型，表示把这个值存在一个内存地址里
   （2）变量的定义规则：变量名只能是字母、数字或下划线的任意组合；第一个字符不能是数字；关键字不能声明为变量名（and、as、assert、break、class、continue、def、elif...）
     (3)变量如果是字符串的数据类型，一定要用引号括起来，可以用单引号‘’或双引号“”（正常情况下，两种没有区分，都可以用）。特别说明：如果字符串里面有单引号，则外面要用双引号括起来；如果字符串里面有双引号，外面就用单引号引起来；若字符串里面单引号和双引号都有，则用三引号括起来''' '''
• 输入输出
  （1）输入分两种：输入后明文显示、输入后暗文显示。输入显示明文的用input（）代替-----备注：python3去掉了raw_input()；输入显示暗文需要用到标准库getpass，具体方法如下：
  |import  getpass #导入python自带的标准getpass模块
  password = getpass.getpass()
  (2)输出使用print()函数实现-----备注：而python2使用的是print语句：print "XXXX"
      python3例子如下：
      name =input(“请输入名字”)
      print(name)
• 条件判断
   （1）句型有：if...else...或if....elif...else。针对if和elif只有判断为true,该分支语句才会执行，只有当if和elif判断都为false时，才会执行else的分支语句。
           例子比如：
          if  天气好：
              我就出去玩
          else:
               我在家里躺尸
  
          if  小明的年纪== 小红的年纪：
                print("年龄相等")
         elif 小明的年年纪 > 小红的年纪
               print("小明大")
         else:
               print(“小红大”)
  （2）多条件判断：若是要同时满足多个条件，用 and；若是只要满足其中的一个条件，则用 or
        举个 例子：
         if username=='admin' and password == '123456':
              print('登录成功！')
         else:
              print('账号/密码输入错误！')
• 循环
  （1）while循环，句型：while...else
  （2）for循环，句型是：for 目标（先定义一个赋值目标） in XX（要遍历的对象）.....else。

  for i  in range(x) 不需要定义count，不用count=+1。同时range()顾头不顾尾，比如range(1,10),包括1，但是不包括10。

  特别说明：for没有判断的意思，只能循环遍历。任何有序的序列对象内的元素都可以遍历，比如：字符串、列表、元组等
                      for...else...如果一次做完了所有的事情（for循环完所有的次数），则会去执行else;若做到一半未循环完就停止下来了（中途遇到break）,就不执行else
  举个例子：

  import os
  
  names= ['huhu','yu','niu']
  for name in names:             #循环遍历整个list
      if os.path.exists(name):#判断脚本所在的目录下是否存在name命名的文件，满足的的返回true,则跳出本次循环；否则创建文件
          continue                    #用list里的下一个name进行判断是否存在
      else:
          os.mkdir(name)
          print("创建")

  
  （3）循环里两个重要的关键字：continue和break。contine的意思是跳出所在循环里的本次循环，继续进入所在循环里的下一次循环；break意思是停止所在的循环，无论循环还有多少次可循环，都停止不能继续。
  举个例子：

  import os
  
  count = 0
  while count <3:
      username = input("请输入用户名：")
      password = input("请输入密码：")
      if username == 'admin' and password == '123456':
          print('欢迎登陆')
          dir_err_count = 0
          while dir_err_count < 2:
              dir_name = input("请输入你的个人文件目录：")
              if os.path.exists(dir_name):
                  dir_err_count = dir_err_count+1
                  print("请重新输入：")
              else:
                  os.mkdir(dir_name)
                  print('文件夹创建成功')
                  break                   #停止内部的创建文件目录的循环，进入外部循环
          break                           #停止外面的重试密码的循环，直接彻底结束
      else:
          print("密码输入错误")
          count=count+1

• 格式化输出
  （1）第一种是使用“+”连接：print(您的年龄“+age”)
            备注：不推荐使用这种方法
  （2）第二种是使用占用符，有%s---后面跟字符串；有%d----后面跟整数，有%f-----后面跟小数：
          print("您的名字%s"%name)
          print("您的名字是%s,年龄是%d"%(name,age))     #多个变量的形式
         print("你的成绩是%.2f"%grade)
  （3）第三种是使用{}和fromat方法：
   

  print('你的名字是{your_name},你的成绩是{your_grade}'.format(your_name=name,your_grade=grade)) #使用format格式化输出，{}里面的名字可以随便写但是要和后面的format中的名字保持一致，然后再把你前面定义的变量写到等号后面就可以了。

  总结：如果参数比较少的情况下用占位符比较简单；如果参数比较多的情况下，用.format 这种方式格式化更为直观
   
• python的数据类型
  （1）整型和浮点型
             整型在python3里只有int类型，没有long类型。整型包括负整数、正整数和0
             浮点型就是float类型，带小数点的
  举个栗子：age = 18  money=100.78

            （2）布尔类型：True和False，并且区分大小写。
          记住一点：非0即真，非空即真，非真即假

           （3）字符串（字符串也可以通过下标取值，用for...in(字符串) ...可以循环列表字符串里的每一个元素；同时字符串是不可变变量，里面的每一个元素是不可修改的。还有一点就是字符串支持切片操作str[start : stop]）
    举个栗子：name = "huhy_test"

    字符串主要常用的内置方法如下：  

1. name = 'hhhhuhy_test'
   print(name.count('hh')) #统计某个字符串出现的次数 

2. print(name.index('t')) #返回某个元素第一次出现位置的下标 

3. print(name.find('x')) #返回某个元素第一次出现位置的下标
   特别说明：index()和find()都是查找字符串的下标，但是两者有区分：find()找不到元素会返回-1，index找不到元素会报错	

4. join（）

   将字符串、字典、元组、列表中的元素以指定的分割符连接生成一个新的字符串。最前面那个是分割符，可以为空。 #对字典进行操作 

   dict = {'marry':['女','北京'],'hu':['','南昌'],'a':['女','上海']} print(','.join(dict)) print(type(','.join(dict)))

   #对字符串进行操作

   str ='abcdcc'
   print(','.join(str))

   #对元组进行操作

   a=('lal','cccc')
   b=','.join(a)
   print(type(b))
   print(b)

   #对列表进行操作

   b=['a','ella']
   c=','.join(b)
   print(type(c))
   print(c)

5. encode()和decode()
   encode是bytes转换成str;decode是str转换成bytes	

6. u = '中文' print(u.endswith('文')) #字符串是否以XX结尾，结果返回true或false

7. print('12u3'.isdigit()) #判断字符串是否全为数字,若字符串里全是数字则返回true,否则返回false

8. name = 'hu,hy,ye'
   print(name.split(','))#通过分隔符来分割字符串，返回一个list

9. print('1+2+3+4\nhllhe'.splitlines())#以换行符分割字符串，返回一个list

10. name = '欢迎你的到来'
    print(name.center(30,'*'))#打印信息，超过name部分，用*代替，直到有30个字符

11. name = 'HyyYYY' print(name.lower())#将全部大写转换成小写

12. name = 'HyyYYY'
    print(name.upper())#将全部小写转换成大写

13. name ='hello world' lis=['a',1,2,3] print(name.capitalize()) #首字母大写 print(name.find('world'))#查找字符串的索引,找到的话返回第一次出现的索引，找不到返回-1 print('aBCE'.isalnum())#是否包含数字和字母 print('aBCE0008j'.isalpha())#是否是英文字母

14. a = ','.join(['hehe', 'haha', 'ee']) # 拼接字符串，把列表变成了字符串 print(a) print(type(a)) print('\nmysql \n'.lstrip()) # 默认去掉左边的空格和换行 print('\nmysql \n'.rstrip()) # 默认去掉右边的空格和换行 print('\nmysql \n'.strip()) # 默认去掉两边边的空格和换行 p = str.maketrans('abcdefg', '1234567') # 前面的字符串和后面的字符串做映射 print('cc ae gg'.translate(p)) # 输出按照上面maketrans做映射后的字符串 print('mysql'.replace('my','oc'))#替换字符串

15. print('cl,1,2,4'.split(',')) print('cl 1 2 4'.split()) #切割字符串，返回一个list,按照你指定的字符串去分割这个字符串，然后放到list里 #如果你什么都不写的话，按照空格来分割

16. import string print(string.ascii_letters+string.digits)#大小写字母+数字 print(string.ascii_lowercase)#所有的小写字母 print(string.ascii_uppercase)#所有的大写字母 print(string.digits)#所有的数字

      (4)列表(可变的变量，可通过下标修改值)

      通过下标访问列表中的元素，下标从0开始计数

 举个栗子： list = [1,2,3,'uuuuuu']  #定义列表

1. 列表的增:两种方法append()、insert()

   name =['huhy','lili','meili'] print(name[3])#通过下标取值 #name.append('msg') #给list从最末尾开始插入值 name.insert(1,'msg')#从指定的位置开始插入，这个1代表下标 print(name) 

2. 列表的删

   list = ['ab',1,2,3,'huhy']
   del list[1]#指定删除列表某个下标对应的值,del是删除变量，也可以del list：删除整个列表
   list.pop()#括号里不填入下标值的话，默认删除列表末尾的一个值

   list.pop(2) #填入下标，则指定删除列表中下标对应的值，同时删除的值也会返回

   list.remove('ab')#直接指定某个值进行删除，不通过下标进行删除，同时删除的值不会返回。注意：若该值在list出现了多次，#该方法则只是删除其中的一个，若想全部删除则得先统计出该值的出现的个数，再循环该次数进行全部删除。

   list =[1,3,3,3,4,5,4,3,9]
   for i in range(list.count(3)):
       list.remove(3)
   print(list)

   list.clear()#清空整个列表的值，该方法只支持python3
3. 列表的改

   list = ['ab',1,2,3,'huhy']
   list[0]='bbbbb' #修改某个位置的值，不存在的下标赋值会报错

4. 列表的查

   list = ['ab',1,2,3,'huhy']
   print(list[2])#获取第3个元素
   print(list[-1])#获取最后一个元素

5. 列表的切片
   （1）切片是另外一种方式获取列表的值，它可以获取多个元素。
   （2）切片是不包含后面的值的，记住：顾头不顾尾
   （3）切片冒号前面的值，省略不写的话，代表取前面所有的值
   （4）切片冒号后面的值，省略不写的话，代表取后面所有的值
   （5）只写一个冒号的话，取整个列表，它可以复制一个新的列表
   （6）步长默认不写的话，是代表隔1，写上步长的话，代表隔几位取一次值
   （7）步长为负数的话，代表从列表的末尾开始取值，是正数的话，就从列表的开头取值

   list = ['ab',1,2,3,'huhy','cc']
   print(list[-1])#取列表最后一个元素
   print(list[:])#取整个列表
   print(list[1:4])#取下标1至下标4之间的值，包括1，不包括4
   print(list[1:-1])#取下标1至最后一位之间的值，包括1，不包括最后一位
   print(list[0:3])#取下标0至3的值，不包括3
   print(list[:3])#效果同上
   print(list[::2])#代表在所有的值里，每隔2个元素取一个
   print(list[1:5:3])#代表从第二个元开始，到第5个元素，每隔3个取一个
   print(list[5:1:-3])#代表从第5个元素，到第二个元素，每隔3个取一次（后面往前取）

6. 列表的内置方法

   list = ['ab','huhy','cc','ab','ab']
   print(list.index('huhy'))#获取某个值对应的下标。如果有多个的话，则返回第一个；如果值不存在的话则会报错
   print(list.index('huhy',3,4)#后面可以加上查找的开始时间和结束时间
   print(list.count('ab'))#查找某个值出现的次数，找不到的话会返回0

   name = ['andashu', 'cc', 'huhy']
   name2 = [1, 2, 3, 4]
   name.extend(name2)#扩展列表，把name2里面的每一个值挨个添加到name里面,该方法无返回值。还有一个方法用name+name2也可以扩展列表。区别在于加号原来的
   #name/name2变量值都没有变，重新生成新的一个变量；而extend修改了name列表值。
   print(name)

   list = [1,2,3,'huhy']
   list.reverse()#反转数组，该笔原数组的值
   print(list)

   list = [1,2,3,9,5]
   list.sort()#排序，根据ASII码来排序，默认升序
   list.sort(reverse=True)#降序
   print(list)
   

   #多维数组,列表一层一层的取 lis = [1,2,'lily',['ab','hl',5]] print(lis[3][2]) #取一个5的值

    （5）元组
           举个栗子：name = (2,'huhy','mam') #定义元组

             1.元组的值不允许修改

             2.元组只有两个方法：count()和index()

             3.如果元组只有一个元素的话，则要在元素后面加一个逗号。比如：tuple=('qdd',)

             4.元组可以通过下标索引访问元组的值，支持切片取值
          

x = (2, 3, 9, 3, 5, 3)
print(x.index(3))  # 获取元组里某个值第一次出现的下标
print(x.count(3))  # 获取元组中某个值出现的次数

 

    （6）字典
         举个栗子：dict = {'marry':[24,'北京']，‘amy’:[56,'南昌']}

           （1）字典是一种key-value的数据类型

           （2）字典是无序的，因为它没有下标，用key可当索引，所以是无序的

           （3）字典的key必须是唯一的，因为它是通过key进行所以的，所以key不能重复，天生去重

          （4）json解码，返回的是一个字典，比如：r.json（）返回的就是字典
           
          字典的增操作：key直接重新赋值和setdefault方法（），区别在于添加存在的key上。

dict = {'marry':[24,'北京'],'lily':[20,'上海'],'huhy':['30','杭州']} dict['lili'] = [54,'厦门'] #若字典里不存在这个key的话，则增加；若存在这个key的话，则更新这个key的值 dict.setdefault('marry1',[28,'北京1'])#setdefault方法若字典里不存在这个key的话，则增加；若存在这个key的话，则不动这个key  

 

          字典的删操作:有三种方法是del、pop()和popitem()
         

dict = {'marry':24,'lili':11,'yeh':80,'yt':56}
del dict['marry']#del 方法指定key进行删除，若可以不存在则会报错
dict.pop('yeh')#pop()方法指定key进行删除，若key不存在则会报错
dict.popitem()#popitem()方法随机删除一个值，无法指定key进行删除
dict.clear()#清空字典

 

 

        字典的改操作：指定key进行重新赋值

dict = {'marry':24,'lili':11,'yeh':80,'yt':56}
dict['marry']=59 #指定key进行重新赋值修改

 

 

     字典的查操作：有四种方法是in方法、指定查询某个key、get()查询某个key方法、keys()查询字典里所有的keys、valus()查询字典里所有的value值。

 

dict = {'marry':24,'lili':11,'yeh':80,'yt':56} print('lili' in dict) #in方法，查询某个key是否存在字典里。存在的话，返回true,不存在的话，返回false print(dict['marry'])#查询某个key的方法，若key不存在的话，会报错 print(dict.get('marry'))

#通过get()方法查询某个key,这种方法如果key不存在的话，会返回None。可以多传一个参数，找不到就返回这个参数
print(dict.keys())#通过keys()方法查询字段里所有的keys
print(dict.values())#通过values方法查询字典里所有的values

   多维嵌套字典的操作：

 

#多维字典的操作，比如：
all  = {
    'car':
        {
            'color':['red','yellow','black'],
            'moeny':1111111,
            'pailiang':"2.5L",
            'name':"BMW"
        } ,
    'car1':
        {
            'color':['red','yellow','brown'],
            'moeny':1111111,
            'pailiang':"2.5L",
            'country':"china"
        },
    'car2':
        {
            'color':['red','yellow','black'],
            'moeny':1111111,
            'pailiang':"2.5L"
        }
}
#若想获得car1下的color值,有两种方法如下：
cl = all['car1']['color']
c2= all.get('car1').get('color')

#若想修改car下color的yellow变成'white'颜色
all.get('car').get('color')[1]='white'#第一种get方法
all['car']['color'][1]='white'#第二种方法指定key重新赋值

#若想在car12再增加一个age的属性
all['car2'].setdefault('age','1992年产')

 

 

   字典的内置方法：

    （1）update()方法，扩展更新字典

dict1 = {'marry':24,'lili':11,'yeh':80,'yt':56}
dict2 = {'lili':'lala','m':23}
dict1.update(dict2)#update()方法扩展字典。更新dict1字典值，如果key存在的话就更新，不存在的话就添加
print(dict1)

 

       （2）items()方法，字典转换成list

 

ict1 = {'marry':24,'lili':11,'yeh':80,'yt':56}
x = dict1.items() #字典转成list

 

     循环字典获取值：两种方式，其中.items（）方法效率比较低。例子如下：

 

dict1 = {'marry':24,'lili':11,'yeh':80,'yt':56}
for key in dict1:
    print(key,dict1[key])#打印key和value的值
for k,v in  dict1.items():
    print(k,v) #items()方法，会把字典转换成列表，打印key和value的值

（7）运算符
         a/b：取整个值
         a//b：取整数，小数省略
        a%b：取余数

 

        not ：非，取反

 

        None：空，代表什么都没有，但是它不是空字符串

         in：判断在不在里面

        is ：判断内存地址是否一样。比如：不可变的字符串值如果一样，则内存地址一样，而可变的列表值一样，而它的内存地址是不一样的。

        ==：判断变量的值是否一样，‘==’不等同于‘is’

         c+=a 相等于c=c+a

         +-需要同类型的进行操作，整型可加减；字符串、元组和列表可通过加来进行拼接
 

（8）集合
          （1）集合类似于列表，特点是无序的，不重复的

         （2）集合天生去重
         （3）集合是用花括号{}

         （4）集合支持用in和not in 操作符检查成员
         （5）由len()内建函数得到集合的长度，用for循环迭代集合的成员。

         （6）因为集合本身是无序的，不可以为集合建立索引或执行切片操作，也没有键keys可用来获取集合中的元素的值
 
      定义集合：

 

lis = ['uu',1,4,5,1,'uu']
s_lis = set(lis)#通过set（）方法定义一个集合，去掉重复的值
print(s_lis)

x = {'u1','u2','u3'}#直接定义一个集合
print(type(x)) #type()方法，可以查询x的类型

 

   集合的功能：

 

list1 = {5,78,3,4,6,89,23,1,3}
list2 ={2,3,4,6,1,7,89}
list3 = {1,3}
list={456,891}

#取交集
print(list1.intersection(list2))
print(list1 & list2)

#取并集,合并两个集合，同时去掉重复性
print(list1.union(list2))
print(list1 | list2)

#取差集,在list里存在，在list2里不存在的项
print(list1.difference(list2))
print(list1 - list2)

#判断是否是子集，list3是不是list1的子集，返回的值是True或者False
print(list3.issubset(list1))

#判断是否是父集，list1是不是list3的父集
print(list1.issuperset(list3))

#判断是否有交集
print(list1.isdisjoint(list))#如果没有交集则返回true,否则返回false
print(list1^list2)#输出各自集合里对方没有的值，去掉都存在的值
list1.add(1111)#添加单个元素
list1.update({77,55})#批量添加元素
list1.remove(23)#删除一个元素，如果元素不存在会报错
print(list1.pop())#删除一个随机元素，并返回删除的元素
list1.discard(986)#删除一个元素，如果元素不存在的话则不处理

 

 （9）三元运算符
 

（10）数据类型的强制转化
          

int(i) #转换成整数
float(x) #转换成浮点数
str() #转换成字符串
list()#转换成列表
tuple()#转换成一个元组
dict()#转换成字典,比如：dict(one=1,two=2)
set() #转换成一个集合

bool()#把一个对象转换成布尔类型

eval()

#字符串转化成字典

 

• python的入门基础就说到这里了，下一篇是python文件操作@~@
  补充一点小知识：不引入第三方变量，交换两个变量的值有两种方法。如下：

  a=1
  b=2
  a,b=b,a#交换a和b的值
  print(a,b)

   

  a=4 b=5 a=a+b b=a-b #b=4 a=a-b #a=5 print(a,b)

  
  下面插一个小程序：150盏点灯亮着，进行1-150顺序编号。逢3的倍数开关一次，然后逢5的倍数开关一次，问最后几盏灯亮着？

  list = [1]*150
  print(list)
  for i in range(0,150):
      if (i+1)%3==0:
         list[i] = -list[i]
      print(list)
  for i in range(0,150):
      if (i+1)%5==0:
          list[i] = -list[i]
  print(list.count(1))