第五篇.python进阶

1. 异常处理

1. 什么是异常

2. 异常的种类

3. 异常的处理

4. try-except总结

5. 抛出异常raise

6. 断言assert

2. 数字类型内置方法

1. 整型内置方法（int）

2.用途：

年龄、号码、等级

2.定义：

可以使用int()方法将纯数字的字符串转为十进制的整型

age = 19  # age = int(10)

print(type(age))

<class 'int'> 

x = int('111')

print(type(x))

<class 'int'> 

x = int('11.1')  # 报错

print(x)

3.常用操作+内置方法：

算术运算+比较运算

4.存一个值or多个值：

一个值

5.有序or无序：

整型麻油有序or无序一说

6.可变和不可变

可变：变量值变了，id不变

不可变：变量值变了，id也变了

整型属于不可变：

age = 19

print(f'first:{id(age)}')

age = 20

print(f'second:{id(age)}')

first:4384901776

second:4384901808

3. 浮点型内置方法（float）

1.用途：

薪资、身高、体重

2.定义：

可以使用float()方法将纯数字的字符串转为浮点型数字。

age = 3.1  # age = float(3.1)

print(type(age))

<class 'float'> 

x = float('111')

print(x)

print(type(x))

111.0

<class 'float'> 

x = float('11.1')  # 报错

print(type(x))

<class 'float'>

3.常用操作+内置方法：

算术运算+比较运算

4.存一个值or多个值：

一个值

5.有序or无序：

无有序or无序一说

浮点型是不可变：

salary = 3.1

print(f'first:{id(salary)}')

salary = 5.1

print(f'second:{id(salary)}')

first:4423173584

second:4423173800

4. 字符串类型内置方法

1.用途：

描述性质的东西，如人的名字、单个爱好、地址、国家等

2.定义：

使用''、""、''''''、""""""包裹的的一串字符

  • u'unicode': unicode编码的字符串

  • b'101': 二进制编码的字符串

  • r'\n': 原生字符串，也就是说'\n'这是普通的两个字符，并没有换行的意思

    name = 'nick'  # name =str('nick')
    
s1 = str(1.1)
    
s2 = str([1, 2, 3])

print(f's1:{s1}, type:{type(s1)}')
    
print(f's2:{s2}, type:{type(s2)}')
    

    s1:1.1, type:<class 'str'>
    
s2:[1, 2, 3], type:<class 'str'>

3.常用操作+内置方法：

常用操作和内置方法分为优先掌握（今天必须得记住）、需要掌握（一周内记住）、其他操作（了解）三个部分。

1.1优先掌握

  1. 按索引取值

  2. 切片

  3. 长度len

  4. 成员运算in/not in

  5. 移除空白strip

  6. 切分split

  7. 循环

    1.按索引取值（只能区，不能改变里面的东西）

    # str索引取值
    
msg = 'hello nick'
    
#      0123456789  # 索引序号

print(f'索引为6: {msg[6]}')
    
print(f'索引为-3: {msg[-3]}')

    索引为6: n

    索引为-3: i

    2.切片（顾头不顾尾：步长）

    # 索引切片
    
msg = 'hello nick'
    
#      0123456789  # 索引序号

print(f'切片3-最后: {msg[3:]}')
    
print(f'切片3-8: {msg[3:8]}')
    
print(f'切片3-8，步长为2: {msg[3:8:2]}')
    
print(f'切片3-最后，步长为2: {msg[3::2]}')

# 了解，步长为正从左到右；步长为负从右到左
    
print('\n**了解知识点**')
    
print(f'切片所有: {msg[:]}')
    
print(f'反转所有: {msg[::-1]}')
    
print(f'切片-5--2: {msg[-5:-2:1]}')
    
print(f'切片-2--5: {msg[-2:-5:-1]}')
    

    切片3-最后: lo nick
    
切片3-8: lo ni
    
切片3-8，步长为2: l i
    
切片3-最后，步长为2: l ik

**了解知识点**
    
切片所有: hello nick
    
反转所有: kcin olleh
    
切片-5--2:  ni
    
切片-2--5: cin

    3.长度len（）

    # str长度
    
msg = 'hello nick'

print(len(msg))

    10

    4.成员运算in/not in

    # str成员运算
    
msg = 'my name is nick, nick handsome'

print(f"'nick' in msg: {'nick' in msg}")
    
print(f"'jason' not in msg: {'jason' not in msg}")
    
print(f"not 'jason' in msg: {not 'jason' in msg}")
    

    'nick' in msg: True
    
'jason' not in msg: True
    
not 'jason' in msg: True

    5.移除空白

    # str移除空白strip()
    
name = '&&&n ick'

print(f"name.strip('&'): {name.strip('&')}")  # strip()默认为‘ ’，并且不修改原值，新创建空间
    
print(f"name: {name}")

# strip()应用场景
    
pwd = input('password: ')  # 用户可能会手抖输入空格
    
if pwd.strip() == '123':
    
    print('密码输入成功')

print(f"'*-& nick+'.strip('*-& +'): {'*-& nick+'.strip('*-& +')}")
    

    name.strip('&'): n ick
    
name: &&&n ick
    
password: 123
    
密码输入成功
    
'*-& nick+'.strip('*-& +'): nick

    5.切分split

    # str切分split
    
info = 'nick:male:19'
    
info_list1 = info.split(':')
    
info_list2 = info.split(':', 1)

print(f'info_list1:{info_list1}')
    
print(f'info_list2:{info_list2}')
    

    info_list1:['nick', 'male', '19']
    
info_list2:['nick', 'male:19']

    7.循环

    msg = 'hello nick'

for i in msg:
    
    print(i)

    1.2需要掌握

    1. lstrip&rstrip

    2. lower&upper

    3. startswith&endswith

    4. rsplit

    5. join

    6. replace

    7. isdigit

      1. .lstrip()和rstrip()

        # str之lstrip()和rstrip()
        
name = '&&nick&&'

print(f"nick.lstrip('&'): {name.lstrip('&')}")
        
print(f"nick.rstrip('&'): {name.rstrip('&')}")
        

        nick.lstrip('&'): nick&&
        
nick.rstrip('&'): &&nick

      2. lower()和upper()

        # str之lower()和upper()
        
name = 'Nick Chen'

print(f"name.upper(): {name.lower()}")
        
print(f"name.upper(): {name.upper()}")
        

        name.upper(): nick chen
        
name.upper(): NICK CHEN

      3. startswith()和endswith()

        # str之startswith()和endswith()
        
name = 'Nick Chen'

print(f"name.startswith('Nick'): {name.startswith('Nick')}")
        
print(f"name.endswith('chen'): {name.endswith('chen')}")
        

        name.startswith('Nick'): True
        
name.endswith('chen'): False

      4. rsplit()

        # str之rsplit()
        
info = 'nick:male:19'

print(f"info.rsplit(':', 1): {info.rsplit(':', 1)}")  # 从右开始切割
        

        info.rsplit(':', 1): ['nick:male', '19']

      5. join()

        lis = [1,2,'19']
        
print(f"':'.join(lis): {':'.join(lis)}")  # 报错，数字不可和字符串拼接
        

        # str之join()
        
lis = ['nick', 'male', '19']

print(f"':'.join(lis): {':'.join(lis)}")

        ':'.join(lis): nick:male:19

      6. replace()

        # str值replace()
        
name = 'nick shuai'

print(f"name.replace('shuai','handsome'): {name.replace('shuai','handsome')}")

        name.replace('shuai','handsome'): nick handsome

      7. isdigit()

        # str值isdigit()
        
salary = '111'
        
print(salary.isdigit())  # True

salary = '111.1'
        
print(salary.isdigit())  # False
        

        True
        
False
        

        # str之isdigit()应用场景
        
age = input('age: ')
        
if age.isdigit():
        
    age = int(age)

    if age < 18:
        
        print('小姐姐')
        
    else:
        
        print('阿姨好')
        
else:
        
    print(f'你的年龄能是这个{age}?')
        

        age: 逗你玩？
        
你的年龄能是这个逗你玩？?

        1.3其他操作

        1. find|rfind|index|rindex|count

        2. center|ljust|rjust|zfill

        3. expandtabs

        4. captalize|swapcase|title

        5. is系列

          1. 1.find()、rfind()、index()、rindex()、count()

          2. center()、ljust()、rjust()、zfill()

          3. expandtabs()

          4. captalize()、swapcase()、title()

          5. is数字系列

          6. is其他

5. 列表类型的内置方法

  1. 列表类型内置方法（list）

    1. 用途：多个装备、多个爱好、多门课程

    2. 定义：[]内可以有多个类型的值，逗号隔开多个元素

      # my_girl_friend = list(['jason','tank','sean'])
      
my_girl_friend = ['jason', 'tank', 'sean']

print(f"my_girl_friend: {my_girl_friend}")
      

      my_girl_friend: ['jason', 'tank', 'sean']
      

      l = list('hello nick')
      
print(f"l: {l}")
      

      l: ['h', 'e', 'l', 'l', 'o', ' ', 'n', 'i', 'c', 'k']

      3.常用操作+内置方法：常用操作和内置方法分为优先掌握（今天必须得记住）、需要掌握（一周内记住）、其他操作（了解）三个部分。

6. 元组类型的内置方法

  1. 元组类型内置方法（tuple）

    1.用途：多个装备、多个爱好、多门课程，甚至是多个女朋友

    2.定义：在()内可以有多个任意类型的值，逗号分隔元素

    # my_girl_friend = tuple(('jason','tank','sean'))
    
my_girl_friend = ('jason', 'tank', 'sean')

print(f"my_girl_friend: {my_girl_friend}")

    my_girl_friend: ('jason', 'tank', 'sean') 

    name_str = ('egon')  # ()只是普通包含的意思
    
name_tuple = ('egon',)

print(f"type(name_str): {type(name_str)}")
    
print(f"type(name_tuple): {type(name_tuple)}")

    type(name_str): <class 'str'>

    type(name_tuple): <class 'tuple'>

    3.常规操作+内置方法：常用方法和内置方法

    1.1 优先掌握

    1. 索引取值

    2. 切片（顾头不顾尾，步长）

    3. 长度len

    4. 成员运算in和not in

    5. 循环

    6. count

    7. index

      1.索引取值

      # tuple之索引取值
      
name_tuple = ('nick', 'jason', 'tank', 'sean')
      
# name_tuple[0] = 'nick handsom'  # 报错

print(f"name_tuple[0]: {name_tuple[0]}"

      name_tuple[0]: nick

      2.切片（顾头不顾尾，步长）

      # tuple之切片
      
name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"name_tuple[1:3:2]: {name_tuple[1:3:2]}")
      

      name_tuple[1:3:2]: ('jason',)

      3.长度

      # tuple之长度
      
name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"len(name_tuple): {len(name_tuple)}")

      len(name_tuple): 4

      4.成员运算

      # tuple之成员运算
      
name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"'nick' in name_tuple: {'nick' in name_tuple}")

      'nick' in name_tuple: True

      5.循环

      # tuple之循环
      
name_tuple = ('nick', 'jason', 'tank', 'sean')

for name in name_tuple:
      
    print(name)

      nick

      jason

      tank

      sean

      6.count

      # tuple之count()
      
name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"name_tuple.count('nick'): {name_tuple.count('nick')}")

      name_tuple.count('nick'): 1

      7.index()

      # tuple之index()
      
name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"name_tuple.index('nick'): {name_tuple.index('nick')}")

      name_tuple.index('nick'): 0

      4.存一个值or多个值：

      多个值

      5.有序or无序：

      有序

      name_tuple = ('nick',)
      
print(f'first:{id(name_tuple)}')

      first:4394454152

      6.可变不可变：

      不可变

      7.元组和列表的区别

      l = ['a', 'b', 'c']
      
print(f"id(l[0]): {id(l[0])}")
      
l[0] = 'A'
      
print(f"id(l[0]): {id(l[0])}")
      

      id(l[0]): 4357367208
      
id(l[0]): 4357775176

      列表可变的原因：索引对应的内存地址是可以改变的

      元组不可变的原因：索引对应的值得内存地址是不可以改变的

      索引对应的地址没有变，则元组的值不会变的

      t1 = (['a', 'b', 'c'], 'wc', 'office')

print(f"id(t1[0]): {id(t1[0])}")
      
print(f"id(t1[1]): {id(t1[1])}")
      
print(f"id(t1[2]): {id(t1[2])}")

t1[0][0] = 'A'
      
print(f"t1[0][0]: {t1[0][0]}")
      
print(f"id(t1[0]): {id(t1[0])}")
      
print(f"t1: {t1}")
      

      id(t1[0]): 4394709960
      
id(t1[1]): 4374626968
      
id(t1[2]): 4394453568
      
t1[0][0]: A
      
id(t1[0]): 4394709960
      
t1: (['A', 'b', 'c'], 'wc', 'office')

7. 字典类型的内置方法

  1. 字典类型内置方法（dict）

    1. 用途：存多个值，但每个值对应一个键，键相当于列表隐藏的索引，所以取值方法和列表有些类似

    2. 定义

      {}内用逗号分隔开多个元素，每一个元素都是key：value的形式，value可以是任意数据类型，而key通常应该是字符串类型，但是key必须为不可变类型。

      dic = {'a': 1, 'b': 2}  # dic = dict({'a':1,'b':2})

print(f"dic: {dic}")
      

      dic: {'a': 1, 'b': 2}
      

      dic = dict(a=1, b=2, c=3)

print(f"dic: {dic}")
      

      dic: {'a': 1, 'b': 2, 'c': 3}
      

      dic = {1: 'a', 0: 'b'}

print(f"dic[0]: {dic[0]}")  # 无法区分dic是列表，还是字典，并且key不再具有描述信息
      
dic[0]: b
      
dic = {[1,2]: 'a', 0: 'b'}  # 报错

      1.1 优先掌握

      1. 按key存值：可存可取

      2. 长度len

      3. 成员运算in和not in

      4. 删除del

      5. 键keys()、值values()、键值对items()

      6. 循环

        1. 按key取值

          # dic之按key存取值
          
dic = {'a': 1, 'b': 2}

print(f"first dic['a']: {dic['a']}")

dic['a'] = 3

print(f"second dic['a']: {dic['a']}")
          

          first dic['a']: 1
          
second dic['a']: 3

          2.长度len

          # dic之长度len
          
dic = {'a': 1, 'b': 2}

print(f"len(dic): {len(dic)}")
          

          len(dic): 2

          3.成员运算in和not in

          # dic之成员运算in和not in
          
dic = {'a': 1, 'b': 2}

print(f"'a' in dic: {'a' in dic}")
          
print(f"1 in dic: {1 in dic}")
          

          'a' in dic: True
          
1 in dic: False

          4.删除

          # dic之删除del
          
dic = {'a': 1, 'b': 2}
          
del dic['a']

print(f"dic.get('a'): {dic.get('a')}")
          

          dic.get('a'): None
          

          # dic之删除pop()
          
dic = {'a': 1, 'b': 2}
          
dic.pop('a')  # 指定元素删除

print(f"dic.pop('b'): {dic.pop('b')}")
          
print(f"dic.get('a'): {dic.get('a')}")
          

          dic.pop('b'): 2
          
dic.get('a'): None
          

          # dic之删除popitem()
          
dic = {'a': 1, 'b': 2}

print(f"dic.popitem(): {dic.popitem()}")  # popitem() 方法随机返回并删除字典中的一对键和值(一般删除末尾对)。
          

          dic.popitem(): ('b', 2)

          5.键keys()、值values()、键值对items()

          # dic之键keys()、值values()、键值对items()，python2中取出的是列表（鸡蛋）；python3中取出的是元组（鸡）
          
dic = {'a': 1, 'b': 2}

print(f"dic.keys(): {dic.keys()}")
          
print(f"dic.values(): {dic.values()}")
          
print(f"dic.items(): {dic.items()}")
          

          dic.keys(): dict_keys(['a', 'b'])
          
dic.values(): dict_values([1, 2])
          
dic.items(): dict_items([('a', 1), ('b', 2)])

          6.循环

          # dic之循环
          
# dic是无序的，但是python3采用了底层优化算法，所以看起来是有序的，但是python2中的字典是无序
          
dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

for k, v in dic.items():  # items可以换成keys()、values()
          
    print(k, v)
          

          a 1
          
b 2
          
c 3
          
d 4

          1.2 需要掌握(****）

          1. get
          2. update
          3. fromkeys
          4. setdefault

          1.get()

          # dic之get()
          
dic = {'a': 1, 'b': 2}

print(f"dic.get('a'): {dic.get('a')}")
          
print(f"dic.get('c'): {dic.get('c')}")
          

          dic.get('a'): 1
          
dic.get('c'): None

          2.update()

          # dic之update()
          
dic1 = {'a': 1, 'b': 2}
          
dic2 = {'c': 3}
          
dic1.update(dic2)

print(f"dic1: {dic1}")
          

          dic1: {'a': 1, 'b': 2, 'c': 3}

          3.fromkeys()

          # dic之fromkeys()
          
dic = dict.fromkeys(['name', 'age', 'sex'], None)

print(f"dic: {dic}")
          

          dic: {'name': None, 'age': None, 'sex': None}

          4.setdefault()

          # dic之setdefault()，有指定key不会改变值；无指定key则改变值
          
dic = {'a': 1, 'b': 2}

print(f"dic.setdefault('a'): {dic.setdefault('a',3)}")
          
print(f"dic: {dic}")
          
print(f"dic.setdefault('c'): {dic.setdefault('c',3)}")
          
print(f"dic: {dic}")
          
dic.setdefault('a'): 1
          
dic: {'a': 1, 'b': 2}
          
dic.setdefault('c'): 3
          
dic: {'a': 1, 'b': 2, 'c': 3}

          二.练习

          统计s='hello tank tank say hello sb sb'中每个单词的个数

          结果如：{'hello': 2, 'tank': 2, 'say': 1, 'sb': 2}

          s='hello tank tank say hello sb sb'

l=s.split()

dic={}
          
for item in l:
          
    if item in dic:
          
        dic[item]+=1
          
    else:
          
        dic[item]=1
          
print(dic)
          

          {'hello': 2, 'tank': 2, 'say': 1, 'sb': 2}

          4.存一个值or多个值：多个值，值可以是多个类型，key必须是不可变类型，通常应该是不可变类型中的字符串类型

          5.有序or无序：无序

          dic = {'a': 1, 'b': 2}
          
print(f'first:{id(name)}')
          
dic['a'] = 3
          
print(f'second:{id(name)}')
          
first:4356627632
          
second:4356627632

          6.可变or不可变：可变数据类型

8. 集合类型的内置方法

  1. 集合类型内置方法（set）

    集合可以理解为集合体

    pythoners = ['jason', 'nick', 'tank', 'sean']
    
linuxers = ['nick', 'egon', 'kevin']

# 即报名pythoners又报名linux的学生
    
py_li_list = []
    
for stu in pythoners:
    
    if stu in linuxers:
    
        py_li_list.append(stu)
    
print(f"pythoners and linuxers: {py_li_list}")

    pythoners and linuxers: ['nick']

    由此可见，用列表方式求两个集合体的关系比较复杂，所以就有了集合数据类型

    2.定义

    **{}内用逗号分隔开多个元素，每个元素必须是不可变类型。 **集合内的元素无序且集合元素不可重复，因此集合可以去重，但是去重后的集合会打乱原来元素的顺序。

    s = {1, 2, 1, 'a'}  # s = set({1,2,'a'})

print(f"s: {s}")
    

    s: {1, 2, 'a'}
    

    s = {1, 2, 1, 'a', 'c'}

for i in s:
    
    print(i)
    

    1
    
2
    
c
    
a
    
s = set('hello')

print(f"s: {s}")
    
s: {'e', 'o', 'h', 'l'}

    1.1 优先掌握

    1. 长度len

    2. 成员运算in和not in

    3. |并集、union

    4. &交集、intersection

    5. -差集、difference

    6. ^对称差集、symmetric_difference

    7. ==

    8. 父集：>、>= 、issuperset

    9. 子集：<、<= 、issubset

      注意：以上的参数都为集合

  2. 练习

9. 数据类型分类

  1. 按存值个数区分

    存值个数 数据类型
    单个值 数字，字符串，浮点型
    多个值(容器) 列表，元组，字典，集合

  2. 按可变不可变区分

    可变or不可变 数据类型
    可变 列表，字典，集合
    不可变 数字，字符串，元组，浮点型

  3. 有序无序之分

    有序or无序 数据类型
    有序(可按索引取值) 字符串，列表，元组
    不可变 字典，集合

  4. 按访问类型区分

    访问类型 数据类型
    直接访问 数字
    顺序访问(序列类型) 字符串，列表，元组
    key值访问(映射类型) 字典

  5. 六大类型内置方法

第五篇.python进阶的更多相关文章

  1. 第五篇python进阶之深浅拷贝

    目录 第五篇python进阶之深浅拷贝 一.引言 1.1可变 和不可变 二.拷贝(只针对可变数据类型) 三.浅拷贝 四.深拷贝 第五篇python进阶之深浅拷贝 一.引言 1.1可变 和不可变 id不 ...

  2. 第二篇 python进阶

    目录 第二篇 python进阶 一 数字类型内置方法 二 字符串类型内置方法 三 列表类型内置方法(list) 四 元组类型内置方法(tuple) 五 字典内置方法 六 集合类型内置方法(self) ...

  3. Python之路(第五篇) Python基本数据类型集合、格式化、函数

    一.变量总结 1.1 变量定义 记录某种状态或者数值,并用某个名称代表这个数值或状态. 1.2 变量在内存中的表现形式 Python 中一切皆为对象,数字是对象,列表是对象,函数也是对象,任何东西都是 ...

  4. 【Python之路】第五篇--Python基础之杂货铺

    字符串格式化 Python的字符串格式化有两种方式: 百分号方式.format方式 百分号的方式相对来说比较老,而format方式则是比较先进的方式,企图替换古老的方式,目前两者并存. 1.百分号方式 ...

  5. 第十五篇 Python之文件处理

    一 文件操作  介绍 计算机系统分为:计算机硬件,操作系统,应用程序三部分. 我们用python或其他语言编写的应用程序若想要把数据永久保存下来,必须要保存于硬盘中,这就涉及到应用程序要操作硬件,众所 ...

  6. 第五篇 Python内置函数

    内置函数 abs() delattr() hash() memoryview() set() all()    dict()  help() min() setattr() any()  dir()  ...

  7. 第五篇Python基本数据类型

    运算符 1. 结果是具体的值:算数运算符和赋值运算符 算数运算符:+.-.*./.**(幂).%(取余).//(取商) print(3-2) # 减法 print(3*2) # 乘法 print(3/ ...

  8. python进阶_浅谈面向对象进阶

    python进阶_浅谈面向对象进阶 学了面向对象三大特性继承,多态,封装.今天我们看看面向对象的一些进阶内容,反射和一些类的内置函数. 一.isinstance和issubclass  class F ...

  9. Python之路【第五篇】：面向对象及相关

    Python之路[第五篇]:面向对象及相关   面向对象基础 基础内容介绍详见一下两篇博文: 面向对象初级篇 面向对象进阶篇 其他相关 一.isinstance(obj, cls) 检查是否obj是否 ...

随机推荐

  1. 数据中心网络架构的问题与演进 — NFV

    目录 文章目录 目录 前文列表 前言 NFV NFV 的最终目标 NFV 的抽象框架 基础架构层与虚拟基础设施管理层 资源管理与业务流程编排层 OSS 层 SDN 控制层 NFV 的生态合作 NFV ...

  2. c/c++编码规范(2)--作用域

    2. 作用域 静止使用class类型的静态或全局变量. 6. 命名约定 6.1. 函数名,变量名,文件名要有描述性,少用缩写. 6.2. 文件命名 6.2.1. 文件名要全部用小写.可使用“_”或&q ...

  3. 爬虫学习笔记之为什么要设置超时时间，怎么设置（使用selenium）

    一个程序没有设置超时时间,就可以说是一段有缺陷的代码. 读取超时指的就是客户端等待服务器发送请求的时间.(特定地,它指的是客户端要等待服务器发送字节之间的时间.在 99.9% 的情况下这指的是服务器发 ...

  4. C#规范整理·资源管理和序列化

    资源管理(尤其是内存回收)曾经是程序员的噩梦,不过在.NET平台上这个噩梦似乎已经不复存在.CLR在后台为垃圾回收做了很多事情,使得我们现在谈起在.NET上进行开发时,都会说还是new一个对象吧!回收 ...

  5. MySQL_数据库命令

    Mysql基础命令 开启MySQL服务:net start mysql 关闭MySQL服务:net stop musql 进入mysql:mysql -h localhost -u root -p 1 ...

  6. oracle -- 查询执行计划，判读查询语句优劣

    以oracle的scott账户:找到员工表中薪水大于本部门平均薪水的员工为例 多表查询方式: select e.empno, e.ename, e.sal, d.avgsal from emp e, ...

  7. acm java入门(转载）

    ACM中java的使用 http://www.cnblogs.com/XBWer/archive/2012/06/24/2560532.html 这里指的java速成,只限于java语法,包括输入输出 ...

  8. python3列表、元组

    列表.元组操作 列表是我们最以后最常用的数据类型之一,通过列表可以对数据实现最方便的存储.修改等操作.列表中的每个元素都分配一个数字也就是它的位置,或叫索引,第一个索引是0,第二个索引是1,依此类推. ...

  9. T100——q查询，子母查询（汇总——明细）练习笔记

    范例: 代码: #add-point:input段落 name="ui_dialog.input" INPUT BY NAME g_master.bdate,g_master.ed ...

  10. postgresql11解压版安装windows

    一.准备安装包 下载地址:https://www.postgresql.org/download/windows/ 二.创建data目录(用于存储数据) 三.进入bin目录执行命令..初始化数据库并设 ...